dma-buf: Rename struct fence to dma_fence

I plan to usurp the short name of struct fence for a core kernel struct, and so I need to rename the specialised fence/timeline for DMA operations to make room. A consensus was reached in https://lists.freedesktop.org/archives/dri-devel/2016-July/113083.html that making clear this fence applies to DMA operations was a good thing. Since then the patch has grown a bit as usage increases, so hopefully it remains a good thing! (v2...: rebase, rerun spatch) v3: Compile on msm, spotted a manual fixup that I broke. v4: Try again for msm, sorry Daniel coccinelle script: @@ @@ - struct fence + struct dma_fence @@ @@ - struct fence_ops + struct dma_fence_ops @@ @@ - struct fence_cb + struct dma_fence_cb @@ @@ - struct fence_array + struct dma_fence_array @@ @@ - enum fence_flag_bits + enum dma_fence_flag_bits @@ @@ ( - fence_init + dma_fence_init | - fence_release + dma_fence_release | - fence_free + dma_fence_free | - fence_get + dma_fence_get | - fence_get_rcu + dma_fence_get_rcu | - fence_put + dma_fence_put | - fence_signal + dma_fence_signal | - fence_signal_locked + dma_fence_signal_locked | - fence_default_wait + dma_fence_default_wait | - fence_add_callback + dma_fence_add_callback | - fence_remove_callback + dma_fence_remove_callback | - fence_enable_sw_signaling + dma_fence_enable_sw_signaling | - fence_is_signaled_locked + dma_fence_is_signaled_locked | - fence_is_signaled + dma_fence_is_signaled | - fence_is_later + dma_fence_is_later | - fence_later + dma_fence_later | - fence_wait_timeout + dma_fence_wait_timeout | - fence_wait_any_timeout + dma_fence_wait_any_timeout | - fence_wait + dma_fence_wait | - fence_context_alloc + dma_fence_context_alloc | - fence_array_create + dma_fence_array_create | - to_fence_array + to_dma_fence_array | - fence_is_array + dma_fence_is_array | - trace_fence_emit + trace_dma_fence_emit | - FENCE_TRACE + DMA_FENCE_TRACE | - FENCE_WARN + DMA_FENCE_WARN | - FENCE_ERR + DMA_FENCE_ERR ) ( ... ) Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk> Reviewed-by: Gustavo Padovan <gustavo.padovan@collabora.co.uk> Acked-by: Sumit Semwal <sumit.semwal@linaro.org> Acked-by: Christian König <christian.koenig@amd.com> Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch> Link: http://patchwork.freedesktop.org/patch/msgid/20161025120045.28839-1-chris@chris-wilson.co.uk
author: Chris Wilson <chris@chris-wilson.co.uk> 2016-10-25 08:00:45 -0400
committer: Daniel Vetter <daniel.vetter@ffwll.ch> 2016-10-25 08:40:39 -0400
commit: f54d1867005c3323f5d8ad83eed823e84226c429 (patch)
tree: 026c3f57bc546d3a0205389d0f8e0d02ce8a76ac /drivers/gpu
parent: 0fc4f78f44e6c6148cee32456f0d0023ec1c1fd8 (diff)
83 files changed, 679 insertions, 665 deletions
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu.h b/drivers/gpu/drm/amd/amdgpu/amdgpu.h
index 039b57e4644c..283d05927d15 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu.h
@@ -34,7 +34,7 @@
 #include <linux/kref.h>
 #include <linux/interval_tree.h>
 #include <linux/hashtable.h>
-#include <linux/fence.h>
+#include <linux/dma-fence.h>
 #include <ttm/ttm_bo_api.h>
 #include <ttm/ttm_bo_driver.h>
@@ -378,7 +378,7 @@ struct amdgpu_fence_driver {
        struct timer_list               fallback_timer;
        unsigned                        num_fences_mask;
        spinlock_t                      lock;
-        struct fence                    **fences;
+        struct dma_fence                **fences;
 };
 /* some special values for the owner field */
@@ -399,7 +399,7 @@ int amdgpu_fence_driver_start_ring(struct amdgpu_ring *ring,
                                   unsigned irq_type);
 void amdgpu_fence_driver_suspend(struct amdgpu_device *adev);
 void amdgpu_fence_driver_resume(struct amdgpu_device *adev);
-int amdgpu_fence_emit(struct amdgpu_ring *ring, struct fence **fence);
+int amdgpu_fence_emit(struct amdgpu_ring *ring, struct dma_fence **fence);
 void amdgpu_fence_process(struct amdgpu_ring *ring);
 int amdgpu_fence_wait_empty(struct amdgpu_ring *ring);
 unsigned amdgpu_fence_count_emitted(struct amdgpu_ring *ring);
@@ -427,7 +427,7 @@ struct amdgpu_bo_va_mapping {
 struct amdgpu_bo_va {
        /* protected by bo being reserved */
        struct list_head                bo_list;
-        struct fence                    *last_pt_update;
+        struct dma_fence                *last_pt_update;
        unsigned                        ref_count;
        /* protected by vm mutex and spinlock */
@@ -543,7 +543,7 @@ struct amdgpu_sa_bo {
        struct amdgpu_sa_manager        *manager;
        unsigned                        soffset;
        unsigned                        eoffset;
-        struct fence                    *fence;
+        struct dma_fence                *fence;
 };
 /*
@@ -566,19 +566,19 @@ int amdgpu_mode_dumb_mmap(struct drm_file *filp,
 */
 struct amdgpu_sync {
        DECLARE_HASHTABLE(fences, 4);
-        struct fence            *last_vm_update;
+        struct dma_fence        *last_vm_update;
 };
 void amdgpu_sync_create(struct amdgpu_sync *sync);
 int amdgpu_sync_fence(struct amdgpu_device *adev, struct amdgpu_sync *sync,
-                      struct fence *f);
+                      struct dma_fence *f);
 int amdgpu_sync_resv(struct amdgpu_device *adev,
                     struct amdgpu_sync *sync,
                     struct reservation_object *resv,
                     void *owner);
-struct fence *amdgpu_sync_peek_fence(struct amdgpu_sync *sync,
+struct dma_fence *amdgpu_sync_peek_fence(struct amdgpu_sync *sync,
                                     struct amdgpu_ring *ring);
-struct fence *amdgpu_sync_get_fence(struct amdgpu_sync *sync);
+struct dma_fence *amdgpu_sync_get_fence(struct amdgpu_sync *sync);
 void amdgpu_sync_free(struct amdgpu_sync *sync);
 int amdgpu_sync_init(void);
 void amdgpu_sync_fini(void);
@@ -703,10 +703,10 @@ struct amdgpu_flip_work {
        uint64_t                        base;
        struct drm_pending_vblank_event *event;
        struct amdgpu_bo                *old_abo;
-        struct fence                    *excl;
+        struct dma_fence                *excl;
        unsigned                        shared_count;
-        struct fence                    **shared;
+        struct dma_fence                **shared;
-        struct fence_cb                 cb;
+        struct dma_fence_cb             cb;
        bool                            async;
 };
@@ -742,7 +742,7 @@ void amdgpu_job_free_resources(struct amdgpu_job *job);
 void amdgpu_job_free(struct amdgpu_job *job);
 int amdgpu_job_submit(struct amdgpu_job *job, struct amdgpu_ring *ring,
                      struct amd_sched_entity *entity, void *owner,
-                      struct fence **f);
+                      struct dma_fence **f);
 struct amdgpu_ring {
        struct amdgpu_device            *adev;
@@ -844,7 +844,7 @@ struct amdgpu_vm {
        /* contains the page directory */
        struct amdgpu_bo        *page_directory;
        unsigned                max_pde_used;
-        struct fence            *page_directory_fence;
+        struct dma_fence        *page_directory_fence;
        uint64_t                last_eviction_counter;
        /* array of page tables, one for each page directory entry */
@@ -865,14 +865,14 @@ struct amdgpu_vm {
 struct amdgpu_vm_id {
        struct list_head        list;
-        struct fence            *first;
+        struct dma_fence        *first;
        struct amdgpu_sync      active;
-        struct fence            *last_flush;
+        struct dma_fence        *last_flush;
        atomic64_t              owner;
        uint64_t                pd_gpu_addr;
        /* last flushed PD/PT update */
-        struct fence            *flushed_updates;
+        struct dma_fence        *flushed_updates;
        uint32_t                current_gpu_reset_count;
@@ -921,7 +921,7 @@ void amdgpu_vm_get_pt_bos(struct amdgpu_device *adev, struct amdgpu_vm *vm,
 void amdgpu_vm_move_pt_bos_in_lru(struct amdgpu_device *adev,
                                  struct amdgpu_vm *vm);
 int amdgpu_vm_grab_id(struct amdgpu_vm *vm, struct amdgpu_ring *ring,
-                      struct amdgpu_sync *sync, struct fence *fence,
+                      struct amdgpu_sync *sync, struct dma_fence *fence,
                      struct amdgpu_job *job);
 int amdgpu_vm_flush(struct amdgpu_ring *ring, struct amdgpu_job *job);
 void amdgpu_vm_reset_id(struct amdgpu_device *adev, unsigned vm_id);
@@ -957,7 +957,7 @@ void amdgpu_vm_bo_rmv(struct amdgpu_device *adev,
 struct amdgpu_ctx_ring {
        uint64_t                sequence;
-        struct fence            **fences;
+        struct dma_fence        **fences;
        struct amd_sched_entity entity;
 };
@@ -966,7 +966,7 @@ struct amdgpu_ctx {
        struct amdgpu_device    *adev;
        unsigned                reset_counter;
        spinlock_t              ring_lock;
-        struct fence            **fences;
+        struct dma_fence        **fences;
        struct amdgpu_ctx_ring  rings[AMDGPU_MAX_RINGS];
        bool preamble_presented;
 };
@@ -982,8 +982,8 @@ struct amdgpu_ctx *amdgpu_ctx_get(struct amdgpu_fpriv *fpriv, uint32_t id);
 int amdgpu_ctx_put(struct amdgpu_ctx *ctx);
 uint64_t amdgpu_ctx_add_fence(struct amdgpu_ctx *ctx, struct amdgpu_ring *ring,
-                              struct fence *fence);
+                              struct dma_fence *fence);
-struct fence *amdgpu_ctx_get_fence(struct amdgpu_ctx *ctx,
+struct dma_fence *amdgpu_ctx_get_fence(struct amdgpu_ctx *ctx,
                                   struct amdgpu_ring *ring, uint64_t seq);
 int amdgpu_ctx_ioctl(struct drm_device *dev, void *data,
@@ -1181,10 +1181,10 @@ struct amdgpu_gfx {
 int amdgpu_ib_get(struct amdgpu_device *adev, struct amdgpu_vm *vm,
                  unsigned size, struct amdgpu_ib *ib);
 void amdgpu_ib_free(struct amdgpu_device *adev, struct amdgpu_ib *ib,
-                    struct fence *f);
+                    struct dma_fence *f);
 int amdgpu_ib_schedule(struct amdgpu_ring *ring, unsigned num_ibs,
-                       struct amdgpu_ib *ib, struct fence *last_vm_update,
+                       struct amdgpu_ib *ib, struct dma_fence *last_vm_update,
-                       struct amdgpu_job *job, struct fence **f);
+                       struct amdgpu_job *job, struct dma_fence **f);
 int amdgpu_ib_pool_init(struct amdgpu_device *adev);
 void amdgpu_ib_pool_fini(struct amdgpu_device *adev);
 int amdgpu_ib_ring_tests(struct amdgpu_device *adev);
@@ -1225,7 +1225,7 @@ struct amdgpu_cs_parser {
        struct amdgpu_bo_list           *bo_list;
        struct amdgpu_bo_list_entry     vm_pd;
        struct list_head                validated;
-        struct fence                    *fence;
+        struct dma_fence                *fence;
        uint64_t                        bytes_moved_threshold;
        uint64_t                        bytes_moved;
        struct amdgpu_bo_list_entry     *evictable;
@@ -1245,7 +1245,7 @@ struct amdgpu_job {
        struct amdgpu_ring      *ring;
        struct amdgpu_sync      sync;
        struct amdgpu_ib        *ibs;
-        struct fence            *fence; /* the hw fence */
+        struct dma_fence        *fence; /* the hw fence */
        uint32_t                preamble_status;
        uint32_t                num_ibs;
        void                    *owner;
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_benchmark.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_benchmark.c
index 345305235349..cc97eee93226 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_benchmark.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_benchmark.c
@@ -33,7 +33,7 @@ static int amdgpu_benchmark_do_move(struct amdgpu_device *adev, unsigned size,
 {
        unsigned long start_jiffies;
        unsigned long end_jiffies;
-        struct fence *fence = NULL;
+        struct dma_fence *fence = NULL;
        int i, r;
        start_jiffies = jiffies;
@@ -43,17 +43,17 @@ static int amdgpu_benchmark_do_move(struct amdgpu_device *adev, unsigned size,
                                       false);
                if (r)
                        goto exit_do_move;
-                r = fence_wait(fence, false);
+                r = dma_fence_wait(fence, false);
                if (r)
                        goto exit_do_move;
-                fence_put(fence);
+                dma_fence_put(fence);
        }
        end_jiffies = jiffies;
        r = jiffies_to_msecs(end_jiffies - start_jiffies);
 exit_do_move:
        if (fence)
-                fence_put(fence);
+                dma_fence_put(fence);
        return r;
 }
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
index b0f6e6957536..5d582265e929 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
@@ -719,7 +719,7 @@ static void amdgpu_cs_parser_fini(struct amdgpu_cs_parser *parser, int error, bo
                ttm_eu_backoff_reservation(&parser->ticket,
                                           &parser->validated);
        }
-        fence_put(parser->fence);
+        dma_fence_put(parser->fence);
        if (parser->ctx)
                amdgpu_ctx_put(parser->ctx);
@@ -756,7 +756,7 @@ static int amdgpu_bo_vm_update_pte(struct amdgpu_cs_parser *p,
        if (p->bo_list) {
                for (i = 0; i < p->bo_list->num_entries; i++) {
-                        struct fence *f;
+                        struct dma_fence *f;
                        /* ignore duplicates */
                        bo = p->bo_list->array[i].robj;
@@ -956,7 +956,7 @@ static int amdgpu_cs_dependencies(struct amdgpu_device *adev,
                for (j = 0; j < num_deps; ++j) {
                        struct amdgpu_ring *ring;
                        struct amdgpu_ctx *ctx;
-                        struct fence *fence;
+                        struct dma_fence *fence;
                        r = amdgpu_cs_get_ring(adev, deps[j].ip_type,
                                               deps[j].ip_instance,
@@ -978,7 +978,7 @@ static int amdgpu_cs_dependencies(struct amdgpu_device *adev,
                        } else if (fence) {
                                r = amdgpu_sync_fence(adev, &p->job->sync,
                                                      fence);
-                                fence_put(fence);
+                                dma_fence_put(fence);
                                amdgpu_ctx_put(ctx);
                                if (r)
                                        return r;
@@ -1008,7 +1008,7 @@ static int amdgpu_cs_submit(struct amdgpu_cs_parser *p,
        job->owner = p->filp;
        job->fence_ctx = entity->fence_context;
-        p->fence = fence_get(&job->base.s_fence->finished);
+        p->fence = dma_fence_get(&job->base.s_fence->finished);
        cs->out.handle = amdgpu_ctx_add_fence(p->ctx, ring, p->fence);
        job->uf_sequence = cs->out.handle;
        amdgpu_job_free_resources(job);
@@ -1091,7 +1091,7 @@ int amdgpu_cs_wait_ioctl(struct drm_device *dev, void *data,
        unsigned long timeout = amdgpu_gem_timeout(wait->in.timeout);
        struct amdgpu_ring *ring = NULL;
        struct amdgpu_ctx *ctx;
-        struct fence *fence;
+        struct dma_fence *fence;
        long r;
        r = amdgpu_cs_get_ring(adev, wait->in.ip_type, wait->in.ip_instance,
@@ -1107,8 +1107,8 @@ int amdgpu_cs_wait_ioctl(struct drm_device *dev, void *data,
        if (IS_ERR(fence))
                r = PTR_ERR(fence);
        else if (fence) {
-                r = fence_wait_timeout(fence, true, timeout);
+                r = dma_fence_wait_timeout(fence, true, timeout);
-                fence_put(fence);
+                dma_fence_put(fence);
        } else
                r = 1;
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ctx.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ctx.c
index a5e2fcbef0f0..99bbc860322f 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ctx.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ctx.c
@@ -35,7 +35,7 @@ static int amdgpu_ctx_init(struct amdgpu_device *adev, struct amdgpu_ctx *ctx)
        kref_init(&ctx->refcount);
        spin_lock_init(&ctx->ring_lock);
        ctx->fences = kcalloc(amdgpu_sched_jobs * AMDGPU_MAX_RINGS,
-                              sizeof(struct fence*), GFP_KERNEL);
+                              sizeof(struct dma_fence*), GFP_KERNEL);
        if (!ctx->fences)
                return -ENOMEM;
@@ -79,7 +79,7 @@ static void amdgpu_ctx_fini(struct amdgpu_ctx *ctx)
        for (i = 0; i < AMDGPU_MAX_RINGS; ++i)
                for (j = 0; j < amdgpu_sched_jobs; ++j)
-                        fence_put(ctx->rings[i].fences[j]);
+                        dma_fence_put(ctx->rings[i].fences[j]);
        kfree(ctx->fences);
        ctx->fences = NULL;
@@ -241,39 +241,39 @@ int amdgpu_ctx_put(struct amdgpu_ctx *ctx)
 }
 uint64_t amdgpu_ctx_add_fence(struct amdgpu_ctx *ctx, struct amdgpu_ring *ring,
-                              struct fence *fence)
+                              struct dma_fence *fence)
 {
        struct amdgpu_ctx_ring *cring = & ctx->rings[ring->idx];
        uint64_t seq = cring->sequence;
        unsigned idx = 0;
-        struct fence *other = NULL;
+        struct dma_fence *other = NULL;
        idx = seq & (amdgpu_sched_jobs - 1);
        other = cring->fences[idx];
        if (other) {
                signed long r;
-                r = fence_wait_timeout(other, false, MAX_SCHEDULE_TIMEOUT);
+                r = dma_fence_wait_timeout(other, false, MAX_SCHEDULE_TIMEOUT);
                if (r < 0)
                        DRM_ERROR("Error (%ld) waiting for fence!\n", r);
        }
-        fence_get(fence);
+        dma_fence_get(fence);
        spin_lock(&ctx->ring_lock);
        cring->fences[idx] = fence;
        cring->sequence++;
        spin_unlock(&ctx->ring_lock);
-        fence_put(other);
+        dma_fence_put(other);
        return seq;
 }
-struct fence *amdgpu_ctx_get_fence(struct amdgpu_ctx *ctx,
+struct dma_fence *amdgpu_ctx_get_fence(struct amdgpu_ctx *ctx,
-                                   struct amdgpu_ring *ring, uint64_t seq)
+                                       struct amdgpu_ring *ring, uint64_t seq)
 {
        struct amdgpu_ctx_ring *cring = & ctx->rings[ring->idx];
-        struct fence *fence;
+        struct dma_fence *fence;
        spin_lock(&ctx->ring_lock);
@@ -288,7 +288,7 @@ struct fence *amdgpu_ctx_get_fence(struct amdgpu_ctx *ctx,
                return NULL;
        }
-        fence = fence_get(cring->fences[seq & (amdgpu_sched_jobs - 1)]);
+        fence = dma_fence_get(cring->fences[seq & (amdgpu_sched_jobs - 1)]);
        spin_unlock(&ctx->ring_lock);
        return fence;
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
index b4f4a9239069..0262b43c8f0e 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
@@ -1599,7 +1599,7 @@ int amdgpu_device_init(struct amdgpu_device *adev,
        adev->vm_manager.vm_pte_funcs = NULL;
        adev->vm_manager.vm_pte_num_rings = 0;
        adev->gart.gart_funcs = NULL;
-        adev->fence_context = fence_context_alloc(AMDGPU_MAX_RINGS);
+        adev->fence_context = dma_fence_context_alloc(AMDGPU_MAX_RINGS);
        adev->smc_rreg = &amdgpu_invalid_rreg;
        adev->smc_wreg = &amdgpu_invalid_wreg;
@@ -2193,7 +2193,7 @@ bool amdgpu_need_backup(struct amdgpu_device *adev)
 static int amdgpu_recover_vram_from_shadow(struct amdgpu_device *adev,
                                           struct amdgpu_ring *ring,
                                           struct amdgpu_bo *bo,
-                                           struct fence **fence)
+                                           struct dma_fence **fence)
 {
        uint32_t domain;
        int r;
@@ -2312,30 +2312,30 @@ retry:
                if (need_full_reset && amdgpu_need_backup(adev)) {
                        struct amdgpu_ring *ring = adev->mman.buffer_funcs_ring;
                        struct amdgpu_bo *bo, *tmp;
-                        struct fence *fence = NULL, *next = NULL;
+                        struct dma_fence *fence = NULL, *next = NULL;
                        DRM_INFO("recover vram bo from shadow\n");
                        mutex_lock(&adev->shadow_list_lock);
                        list_for_each_entry_safe(bo, tmp, &adev->shadow_list, shadow_list) {
                                amdgpu_recover_vram_from_shadow(adev, ring, bo, &next);
                                if (fence) {
-                                        r = fence_wait(fence, false);
+                                        r = dma_fence_wait(fence, false);
                                        if (r) {
                                                WARN(r, "recovery from shadow isn't comleted\n");
                                                break;
                                        }
                                }
-                                fence_put(fence);
+                                dma_fence_put(fence);
                                fence = next;
                        }
                        mutex_unlock(&adev->shadow_list_lock);
                        if (fence) {
-                                r = fence_wait(fence, false);
+                                r = dma_fence_wait(fence, false);
                                if (r)
                                        WARN(r, "recovery from shadow isn't comleted\n");
                        }
-                        fence_put(fence);
+                        dma_fence_put(fence);
                }
                for (i = 0; i < AMDGPU_MAX_RINGS; ++i) {
                        struct amdgpu_ring *ring = adev->rings[i];
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c
index 083e2b429872..075c0d7db205 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c
@@ -35,29 +35,29 @@
 #include <drm/drm_crtc_helper.h>
 #include <drm/drm_edid.h>
-static void amdgpu_flip_callback(struct fence *f, struct fence_cb *cb)
+static void amdgpu_flip_callback(struct dma_fence *f, struct dma_fence_cb *cb)
 {
        struct amdgpu_flip_work *work =
                container_of(cb, struct amdgpu_flip_work, cb);
-        fence_put(f);
+        dma_fence_put(f);
        schedule_work(&work->flip_work.work);
 }
 static bool amdgpu_flip_handle_fence(struct amdgpu_flip_work *work,
-                                     struct fence **f)
+                                     struct dma_fence **f)
 {
-        struct fence *fence= *f;
+        struct dma_fence *fence= *f;
        if (fence == NULL)
                return false;
        *f = NULL;
-        if (!fence_add_callback(fence, &work->cb, amdgpu_flip_callback))
+        if (!dma_fence_add_callback(fence, &work->cb, amdgpu_flip_callback))
                return true;
-        fence_put(fence);
+        dma_fence_put(fence);
        return false;
 }
@@ -244,9 +244,9 @@ unreserve:
 cleanup:
        amdgpu_bo_unref(&work->old_abo);
-        fence_put(work->excl);
+        dma_fence_put(work->excl);
        for (i = 0; i < work->shared_count; ++i)
-                fence_put(work->shared[i]);
+                dma_fence_put(work->shared[i]);
        kfree(work->shared);
        kfree(work);
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c
index 3a2e42f4b897..57552c79ec58 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c
@@ -48,7 +48,7 @@
 */
 struct amdgpu_fence {
-        struct fence base;
+        struct dma_fence base;
        /* RB, DMA, etc. */
        struct amdgpu_ring              *ring;
@@ -73,8 +73,8 @@ void amdgpu_fence_slab_fini(void)
 /*
 * Cast helper
 */
-static const struct fence_ops amdgpu_fence_ops;
+static const struct dma_fence_ops amdgpu_fence_ops;
-static inline struct amdgpu_fence *to_amdgpu_fence(struct fence *f)
+static inline struct amdgpu_fence *to_amdgpu_fence(struct dma_fence *f)
 {
        struct amdgpu_fence *__f = container_of(f, struct amdgpu_fence, base);
@@ -130,11 +130,11 @@ static u32 amdgpu_fence_read(struct amdgpu_ring *ring)
 * Emits a fence command on the requested ring (all asics).
 * Returns 0 on success, -ENOMEM on failure.
 */
-int amdgpu_fence_emit(struct amdgpu_ring *ring, struct fence **f)
+int amdgpu_fence_emit(struct amdgpu_ring *ring, struct dma_fence **f)
 {
        struct amdgpu_device *adev = ring->adev;
        struct amdgpu_fence *fence;
-        struct fence *old, **ptr;
+        struct dma_fence *old, **ptr;
        uint32_t seq;
        fence = kmem_cache_alloc(amdgpu_fence_slab, GFP_KERNEL);
@@ -143,10 +143,10 @@ int amdgpu_fence_emit(struct amdgpu_ring *ring, struct fence **f)
        seq = ++ring->fence_drv.sync_seq;
        fence->ring = ring;
-        fence_init(&fence->base, &amdgpu_fence_ops,
+        dma_fence_init(&fence->base, &amdgpu_fence_ops,
-                   &ring->fence_drv.lock,
+                       &ring->fence_drv.lock,
-                   adev->fence_context + ring->idx,
+                       adev->fence_context + ring->idx,
-                   seq);
+                       seq);
        amdgpu_ring_emit_fence(ring, ring->fence_drv.gpu_addr,
                               seq, AMDGPU_FENCE_FLAG_INT);
@@ -155,12 +155,12 @@ int amdgpu_fence_emit(struct amdgpu_ring *ring, struct fence **f)
         * emitting the fence would mess up the hardware ring buffer.
         */
        old = rcu_dereference_protected(*ptr, 1);
-        if (old && !fence_is_signaled(old)) {
+        if (old && !dma_fence_is_signaled(old)) {
                DRM_INFO("rcu slot is busy\n");
-                fence_wait(old, false);
+                dma_fence_wait(old, false);
        }
-        rcu_assign_pointer(*ptr, fence_get(&fence->base));
+        rcu_assign_pointer(*ptr, dma_fence_get(&fence->base));
        *f = &fence->base;
@@ -211,7 +211,7 @@ void amdgpu_fence_process(struct amdgpu_ring *ring)
        seq &= drv->num_fences_mask;
        do {
-                struct fence *fence, **ptr;
+                struct dma_fence *fence, **ptr;
                ++last_seq;
                last_seq &= drv->num_fences_mask;
@@ -224,13 +224,13 @@ void amdgpu_fence_process(struct amdgpu_ring *ring)
                if (!fence)
                        continue;
-                r = fence_signal(fence);
+                r = dma_fence_signal(fence);
                if (!r)
-                        FENCE_TRACE(fence, "signaled from irq context\n");
+                        DMA_FENCE_TRACE(fence, "signaled from irq context\n");
                else
                        BUG();
-                fence_put(fence);
+                dma_fence_put(fence);
        } while (last_seq != seq);
 }
@@ -260,7 +260,7 @@ static void amdgpu_fence_fallback(unsigned long arg)
 int amdgpu_fence_wait_empty(struct amdgpu_ring *ring)
 {
        uint64_t seq = ACCESS_ONCE(ring->fence_drv.sync_seq);
-        struct fence *fence, **ptr;
+        struct dma_fence *fence, **ptr;
        int r;
        if (!seq)
@@ -269,14 +269,14 @@ int amdgpu_fence_wait_empty(struct amdgpu_ring *ring)
        ptr = &ring->fence_drv.fences[seq & ring->fence_drv.num_fences_mask];
        rcu_read_lock();
        fence = rcu_dereference(*ptr);
-        if (!fence || !fence_get_rcu(fence)) {
+        if (!fence || !dma_fence_get_rcu(fence)) {
                rcu_read_unlock();
                return 0;
        }
        rcu_read_unlock();
-        r = fence_wait(fence, false);
+        r = dma_fence_wait(fence, false);
-        fence_put(fence);
+        dma_fence_put(fence);
        return r;
 }
@@ -452,7 +452,7 @@ void amdgpu_fence_driver_fini(struct amdgpu_device *adev)
                amd_sched_fini(&ring->sched);
                del_timer_sync(&ring->fence_drv.fallback_timer);
                for (j = 0; j <= ring->fence_drv.num_fences_mask; ++j)
-                        fence_put(ring->fence_drv.fences[j]);
+                        dma_fence_put(ring->fence_drv.fences[j]);
                kfree(ring->fence_drv.fences);
                ring->fence_drv.fences = NULL;
                ring->fence_drv.initialized = false;
@@ -541,12 +541,12 @@ void amdgpu_fence_driver_force_completion(struct amdgpu_device *adev)
 * Common fence implementation
 */
-static const char *amdgpu_fence_get_driver_name(struct fence *fence)
+static const char *amdgpu_fence_get_driver_name(struct dma_fence *fence)
 {
        return "amdgpu";
 }
-static const char *amdgpu_fence_get_timeline_name(struct fence *f)
+static const char *amdgpu_fence_get_timeline_name(struct dma_fence *f)
 {
        struct amdgpu_fence *fence = to_amdgpu_fence(f);
        return (const char *)fence->ring->name;
@@ -560,7 +560,7 @@ static const char *amdgpu_fence_get_timeline_name(struct fence *f)
 * to fence_queue that checks if this fence is signaled, and if so it
 * signals the fence and removes itself.
 */
-static bool amdgpu_fence_enable_signaling(struct fence *f)
+static bool amdgpu_fence_enable_signaling(struct dma_fence *f)
 {
        struct amdgpu_fence *fence = to_amdgpu_fence(f);
        struct amdgpu_ring *ring = fence->ring;
@@ -568,7 +568,7 @@ static bool amdgpu_fence_enable_signaling(struct fence *f)
        if (!timer_pending(&ring->fence_drv.fallback_timer))
                amdgpu_fence_schedule_fallback(ring);
-        FENCE_TRACE(&fence->base, "armed on ring %i!\n", ring->idx);
+        DMA_FENCE_TRACE(&fence->base, "armed on ring %i!\n", ring->idx);
        return true;
 }
@@ -582,7 +582,7 @@ static bool amdgpu_fence_enable_signaling(struct fence *f)
 */
 static void amdgpu_fence_free(struct rcu_head *rcu)
 {
-        struct fence *f = container_of(rcu, struct fence, rcu);
+        struct dma_fence *f = container_of(rcu, struct dma_fence, rcu);
        struct amdgpu_fence *fence = to_amdgpu_fence(f);
        kmem_cache_free(amdgpu_fence_slab, fence);
 }
@@ -595,16 +595,16 @@ static void amdgpu_fence_free(struct rcu_head *rcu)
 * This function is called when the reference count becomes zero.
 * It just RCU schedules freeing up the fence.
 */
-static void amdgpu_fence_release(struct fence *f)
+static void amdgpu_fence_release(struct dma_fence *f)
 {
        call_rcu(&f->rcu, amdgpu_fence_free);
 }
-static const struct fence_ops amdgpu_fence_ops = {
+static const struct dma_fence_ops amdgpu_fence_ops = {
        .get_driver_name = amdgpu_fence_get_driver_name,
        .get_timeline_name = amdgpu_fence_get_timeline_name,
        .enable_signaling = amdgpu_fence_enable_signaling,
-        .wait = fence_default_wait,
+        .wait = dma_fence_default_wait,
        .release = amdgpu_fence_release,
 };
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ib.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ib.c
index 6a6c86c9c169..c3672dfcfd6a 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ib.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ib.c
@@ -89,7 +89,7 @@ int amdgpu_ib_get(struct amdgpu_device *adev, struct amdgpu_vm *vm,
 * Free an IB (all asics).
 */
 void amdgpu_ib_free(struct amdgpu_device *adev, struct amdgpu_ib *ib,
-                    struct fence *f)
+                    struct dma_fence *f)
 {
        amdgpu_sa_bo_free(adev, &ib->sa_bo, f);
 }
@@ -116,8 +116,8 @@ void amdgpu_ib_free(struct amdgpu_device *adev, struct amdgpu_ib *ib,
 * to SI there was just a DE IB.
 */
 int amdgpu_ib_schedule(struct amdgpu_ring *ring, unsigned num_ibs,
-                       struct amdgpu_ib *ibs, struct fence *last_vm_update,
+                       struct amdgpu_ib *ibs, struct dma_fence *last_vm_update,
-                       struct amdgpu_job *job, struct fence **f)
+                       struct amdgpu_job *job, struct dma_fence **f)
 {
        struct amdgpu_device *adev = ring->adev;
        struct amdgpu_ib *ib = &ibs[0];
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_job.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_job.c
index 8c5807994073..a0de6286c453 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_job.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_job.c
@@ -81,7 +81,7 @@ int amdgpu_job_alloc_with_ib(struct amdgpu_device *adev, unsigned size,
 void amdgpu_job_free_resources(struct amdgpu_job *job)
 {
-        struct fence *f;
+        struct dma_fence *f;
        unsigned i;
        /* use sched fence if available */
@@ -95,7 +95,7 @@ static void amdgpu_job_free_cb(struct amd_sched_job *s_job)
 {
        struct amdgpu_job *job = container_of(s_job, struct amdgpu_job, base);
-        fence_put(job->fence);
+        dma_fence_put(job->fence);
        amdgpu_sync_free(&job->sync);
        kfree(job);
 }
@@ -104,14 +104,14 @@ void amdgpu_job_free(struct amdgpu_job *job)
 {
        amdgpu_job_free_resources(job);
-        fence_put(job->fence);
+        dma_fence_put(job->fence);
        amdgpu_sync_free(&job->sync);
        kfree(job);
 }
 int amdgpu_job_submit(struct amdgpu_job *job, struct amdgpu_ring *ring,
                      struct amd_sched_entity *entity, void *owner,
-                      struct fence **f)
+                      struct dma_fence **f)
 {
        int r;
        job->ring = ring;
@@ -125,19 +125,19 @@ int amdgpu_job_submit(struct amdgpu_job *job, struct amdgpu_ring *ring,
        job->owner = owner;
        job->fence_ctx = entity->fence_context;
-        *f = fence_get(&job->base.s_fence->finished);
+        *f = dma_fence_get(&job->base.s_fence->finished);
        amdgpu_job_free_resources(job);
        amd_sched_entity_push_job(&job->base);
        return 0;
 }
-static struct fence *amdgpu_job_dependency(struct amd_sched_job *sched_job)
+static struct dma_fence *amdgpu_job_dependency(struct amd_sched_job *sched_job)
 {
        struct amdgpu_job *job = to_amdgpu_job(sched_job);
        struct amdgpu_vm *vm = job->vm;
-        struct fence *fence = amdgpu_sync_get_fence(&job->sync);
+        struct dma_fence *fence = amdgpu_sync_get_fence(&job->sync);
        if (fence == NULL && vm && !job->vm_id) {
                struct amdgpu_ring *ring = job->ring;
@@ -155,9 +155,9 @@ static struct fence *amdgpu_job_dependency(struct amd_sched_job *sched_job)
        return fence;
 }
-static struct fence *amdgpu_job_run(struct amd_sched_job *sched_job)
+static struct dma_fence *amdgpu_job_run(struct amd_sched_job *sched_job)
 {
-        struct fence *fence = NULL;
+        struct dma_fence *fence = NULL;
        struct amdgpu_job *job;
        int r;
@@ -176,8 +176,8 @@ static struct fence *amdgpu_job_run(struct amd_sched_job *sched_job)
                DRM_ERROR("Error scheduling IBs (%d)\n", r);
        /* if gpu reset, hw fence will be replaced here */
-        fence_put(job->fence);
+        dma_fence_put(job->fence);
-        job->fence = fence_get(fence);
+        job->fence = dma_fence_get(fence);
        amdgpu_job_free_resources(job);
        return fence;
 }
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_object.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_object.c
index aa074fac0c7f..55e142a5ff5f 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_object.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_object.c
@@ -383,7 +383,7 @@ int amdgpu_bo_create_restricted(struct amdgpu_device *adev,
        if (flags & AMDGPU_GEM_CREATE_VRAM_CLEARED &&
            bo->tbo.mem.placement & TTM_PL_FLAG_VRAM) {
-                struct fence *fence;
+                struct dma_fence *fence;
                if (adev->mman.buffer_funcs_ring == NULL ||
                   !adev->mman.buffer_funcs_ring->ready) {
@@ -403,9 +403,9 @@ int amdgpu_bo_create_restricted(struct amdgpu_device *adev,
                amdgpu_fill_buffer(bo, 0, bo->tbo.resv, &fence);
                amdgpu_bo_fence(bo, fence, false);
                amdgpu_bo_unreserve(bo);
-                fence_put(bo->tbo.moving);
+                dma_fence_put(bo->tbo.moving);
-                bo->tbo.moving = fence_get(fence);
+                bo->tbo.moving = dma_fence_get(fence);
-                fence_put(fence);
+                dma_fence_put(fence);
        }
        *bo_ptr = bo;
@@ -491,7 +491,7 @@ int amdgpu_bo_backup_to_shadow(struct amdgpu_device *adev,
                               struct amdgpu_ring *ring,
                               struct amdgpu_bo *bo,
                               struct reservation_object *resv,
-                               struct fence **fence,
+                               struct dma_fence **fence,
                               bool direct)
 {
@@ -523,7 +523,7 @@ int amdgpu_bo_restore_from_shadow(struct amdgpu_device *adev,
                                  struct amdgpu_ring *ring,
                                  struct amdgpu_bo *bo,
                                  struct reservation_object *resv,
-                                  struct fence **fence,
+                                  struct dma_fence **fence,
                                  bool direct)
 {
@@ -926,7 +926,7 @@ int amdgpu_bo_fault_reserve_notify(struct ttm_buffer_object *bo)
 * @shared: true if fence should be added shared
 *
 */
-void amdgpu_bo_fence(struct amdgpu_bo *bo, struct fence *fence,
+void amdgpu_bo_fence(struct amdgpu_bo *bo, struct dma_fence *fence,
                     bool shared)
 {
        struct reservation_object *resv = bo->tbo.resv;
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_object.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_object.h
index 8255034d73eb..3e785ed3cb4b 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_object.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_object.h
@@ -156,19 +156,19 @@ int amdgpu_bo_get_metadata(struct amdgpu_bo *bo, void *buffer,
 void amdgpu_bo_move_notify(struct ttm_buffer_object *bo,
                                  struct ttm_mem_reg *new_mem);
 int amdgpu_bo_fault_reserve_notify(struct ttm_buffer_object *bo);
-void amdgpu_bo_fence(struct amdgpu_bo *bo, struct fence *fence,
+void amdgpu_bo_fence(struct amdgpu_bo *bo, struct dma_fence *fence,
                     bool shared);
 u64 amdgpu_bo_gpu_offset(struct amdgpu_bo *bo);
 int amdgpu_bo_backup_to_shadow(struct amdgpu_device *adev,
                               struct amdgpu_ring *ring,
                               struct amdgpu_bo *bo,
                               struct reservation_object *resv,
-                               struct fence **fence, bool direct);
+                               struct dma_fence **fence, bool direct);
 int amdgpu_bo_restore_from_shadow(struct amdgpu_device *adev,
                                  struct amdgpu_ring *ring,
                                  struct amdgpu_bo *bo,
                                  struct reservation_object *resv,
-                                  struct fence **fence,
+                                  struct dma_fence **fence,
                                  bool direct);
@@ -200,7 +200,7 @@ int amdgpu_sa_bo_new(struct amdgpu_sa_manager *sa_manager,
                     unsigned size, unsigned align);
 void amdgpu_sa_bo_free(struct amdgpu_device *adev,
                              struct amdgpu_sa_bo **sa_bo,
-                              struct fence *fence);
+                              struct dma_fence *fence);
 #if defined(CONFIG_DEBUG_FS)
 void amdgpu_sa_bo_dump_debug_info(struct amdgpu_sa_manager *sa_manager,
                                         struct seq_file *m);
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_sa.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_sa.c
index d8af37a845f4..fd26c4b8d793 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_sa.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_sa.c
@@ -147,7 +147,7 @@ static void amdgpu_sa_bo_remove_locked(struct amdgpu_sa_bo *sa_bo)
        }
        list_del_init(&sa_bo->olist);
        list_del_init(&sa_bo->flist);
-        fence_put(sa_bo->fence);
+        dma_fence_put(sa_bo->fence);
        kfree(sa_bo);
 }
@@ -161,7 +161,7 @@ static void amdgpu_sa_bo_try_free(struct amdgpu_sa_manager *sa_manager)
        sa_bo = list_entry(sa_manager->hole->next, struct amdgpu_sa_bo, olist);
        list_for_each_entry_safe_from(sa_bo, tmp, &sa_manager->olist, olist) {
                if (sa_bo->fence == NULL ||
-                    !fence_is_signaled(sa_bo->fence)) {
+                    !dma_fence_is_signaled(sa_bo->fence)) {
                        return;
                }
                amdgpu_sa_bo_remove_locked(sa_bo);
@@ -244,7 +244,7 @@ static bool amdgpu_sa_event(struct amdgpu_sa_manager *sa_manager,
 }
 static bool amdgpu_sa_bo_next_hole(struct amdgpu_sa_manager *sa_manager,
-                                   struct fence **fences,
+                                   struct dma_fence **fences,
                                   unsigned *tries)
 {
        struct amdgpu_sa_bo *best_bo = NULL;
@@ -272,7 +272,7 @@ static bool amdgpu_sa_bo_next_hole(struct amdgpu_sa_manager *sa_manager,
                sa_bo = list_first_entry(&sa_manager->flist[i],
                                         struct amdgpu_sa_bo, flist);
-                if (!fence_is_signaled(sa_bo->fence)) {
+                if (!dma_fence_is_signaled(sa_bo->fence)) {
                        fences[i] = sa_bo->fence;
                        continue;
                }
@@ -314,7 +314,7 @@ int amdgpu_sa_bo_new(struct amdgpu_sa_manager *sa_manager,
                     struct amdgpu_sa_bo **sa_bo,
                     unsigned size, unsigned align)
 {
-        struct fence *fences[AMDGPU_SA_NUM_FENCE_LISTS];
+        struct dma_fence *fences[AMDGPU_SA_NUM_FENCE_LISTS];
        unsigned tries[AMDGPU_SA_NUM_FENCE_LISTS];
        unsigned count;
        int i, r;
@@ -356,14 +356,14 @@ int amdgpu_sa_bo_new(struct amdgpu_sa_manager *sa_manager,
                for (i = 0, count = 0; i < AMDGPU_SA_NUM_FENCE_LISTS; ++i)
                        if (fences[i])
-                                fences[count++] = fence_get(fences[i]);
+                                fences[count++] = dma_fence_get(fences[i]);
                if (count) {
                        spin_unlock(&sa_manager->wq.lock);
-                        t = fence_wait_any_timeout(fences, count, false,
+                        t = dma_fence_wait_any_timeout(fences, count, false,
-                                                   MAX_SCHEDULE_TIMEOUT);
+                                                       MAX_SCHEDULE_TIMEOUT);
                        for (i = 0; i < count; ++i)
-                                fence_put(fences[i]);
+                                dma_fence_put(fences[i]);
                        r = (t > 0) ? 0 : t;
                        spin_lock(&sa_manager->wq.lock);
@@ -384,7 +384,7 @@ int amdgpu_sa_bo_new(struct amdgpu_sa_manager *sa_manager,
 }
 void amdgpu_sa_bo_free(struct amdgpu_device *adev, struct amdgpu_sa_bo **sa_bo,
-                       struct fence *fence)
+                       struct dma_fence *fence)
 {
        struct amdgpu_sa_manager *sa_manager;
@@ -394,10 +394,10 @@ void amdgpu_sa_bo_free(struct amdgpu_device *adev, struct amdgpu_sa_bo **sa_bo,
        sa_manager = (*sa_bo)->manager;
        spin_lock(&sa_manager->wq.lock);
-        if (fence && !fence_is_signaled(fence)) {
+        if (fence && !dma_fence_is_signaled(fence)) {
                uint32_t idx;
-                (*sa_bo)->fence = fence_get(fence);
+                (*sa_bo)->fence = dma_fence_get(fence);
                idx = fence->context % AMDGPU_SA_NUM_FENCE_LISTS;
                list_add_tail(&(*sa_bo)->flist, &sa_manager->flist[idx]);
        } else {
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_sync.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_sync.c
index 5c8d3022fb87..ed814e6d0207 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_sync.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_sync.c
@@ -34,7 +34,7 @@
 struct amdgpu_sync_entry {
        struct hlist_node       node;
-        struct fence            *fence;
+        struct dma_fence        *fence;
 };
 static struct kmem_cache *amdgpu_sync_slab;
@@ -60,7 +60,8 @@ void amdgpu_sync_create(struct amdgpu_sync *sync)
 *
 * Test if the fence was issued by us.
 */
-static bool amdgpu_sync_same_dev(struct amdgpu_device *adev, struct fence *f)
+static bool amdgpu_sync_same_dev(struct amdgpu_device *adev,
+                                 struct dma_fence *f)
 {
        struct amd_sched_fence *s_fence = to_amd_sched_fence(f);
@@ -81,7 +82,7 @@ static bool amdgpu_sync_same_dev(struct amdgpu_device *adev, struct fence *f)
 *
 * Extract who originally created the fence.
 */
-static void *amdgpu_sync_get_owner(struct fence *f)
+static void *amdgpu_sync_get_owner(struct dma_fence *f)
 {
        struct amd_sched_fence *s_fence = to_amd_sched_fence(f);
@@ -99,13 +100,14 @@ static void *amdgpu_sync_get_owner(struct fence *f)
 *
 * Either keep the existing fence or the new one, depending which one is later.
 */
-static void amdgpu_sync_keep_later(struct fence **keep, struct fence *fence)
+static void amdgpu_sync_keep_later(struct dma_fence **keep,
+                                   struct dma_fence *fence)
 {
-        if (*keep && fence_is_later(*keep, fence))
+        if (*keep && dma_fence_is_later(*keep, fence))
                return;
-        fence_put(*keep);
+        dma_fence_put(*keep);
-        *keep = fence_get(fence);
+        *keep = dma_fence_get(fence);
 }
 /**
@@ -117,7 +119,7 @@ static void amdgpu_sync_keep_later(struct fence **keep, struct fence *fence)
 * Tries to add the fence to an existing hash entry. Returns true when an entry
 * was found, false otherwise.
 */
-static bool amdgpu_sync_add_later(struct amdgpu_sync *sync, struct fence *f)
+static bool amdgpu_sync_add_later(struct amdgpu_sync *sync, struct dma_fence *f)
 {
        struct amdgpu_sync_entry *e;
@@ -139,7 +141,7 @@ static bool amdgpu_sync_add_later(struct amdgpu_sync *sync, struct fence *f)
 *
 */
 int amdgpu_sync_fence(struct amdgpu_device *adev, struct amdgpu_sync *sync,
-                      struct fence *f)
+                      struct dma_fence *f)
 {
        struct amdgpu_sync_entry *e;
@@ -158,7 +160,7 @@ int amdgpu_sync_fence(struct amdgpu_device *adev, struct amdgpu_sync *sync,
                return -ENOMEM;
        hash_add(sync->fences, &e->node, f->context);
-        e->fence = fence_get(f);
+        e->fence = dma_fence_get(f);
        return 0;
 }
@@ -177,7 +179,7 @@ int amdgpu_sync_resv(struct amdgpu_device *adev,
                     void *owner)
 {
        struct reservation_object_list *flist;
-        struct fence *f;
+        struct dma_fence *f;
        void *fence_owner;
        unsigned i;
        int r = 0;
@@ -231,15 +233,15 @@ int amdgpu_sync_resv(struct amdgpu_device *adev,
 * Returns the next fence not signaled yet without removing it from the sync
 * object.
 */
-struct fence *amdgpu_sync_peek_fence(struct amdgpu_sync *sync,
+struct dma_fence *amdgpu_sync_peek_fence(struct amdgpu_sync *sync,
-                                     struct amdgpu_ring *ring)
+                                         struct amdgpu_ring *ring)
 {
        struct amdgpu_sync_entry *e;
        struct hlist_node *tmp;
        int i;
        hash_for_each_safe(sync->fences, i, tmp, e, node) {
-                struct fence *f = e->fence;
+                struct dma_fence *f = e->fence;
                struct amd_sched_fence *s_fence = to_amd_sched_fence(f);
                if (ring && s_fence) {
@@ -247,16 +249,16 @@ struct fence *amdgpu_sync_peek_fence(struct amdgpu_sync *sync,
                         * when they are scheduled.
                         */
                        if (s_fence->sched == &ring->sched) {
-                                if (fence_is_signaled(&s_fence->scheduled))
+                                if (dma_fence_is_signaled(&s_fence->scheduled))
                                        continue;
                                return &s_fence->scheduled;
                        }
                }
-                if (fence_is_signaled(f)) {
+                if (dma_fence_is_signaled(f)) {
                        hash_del(&e->node);
-                        fence_put(f);
+                        dma_fence_put(f);
                        kmem_cache_free(amdgpu_sync_slab, e);
                        continue;
                }
@@ -274,11 +276,11 @@ struct fence *amdgpu_sync_peek_fence(struct amdgpu_sync *sync,
 *
 * Get and removes the next fence from the sync object not signaled yet.
 */
-struct fence *amdgpu_sync_get_fence(struct amdgpu_sync *sync)
+struct dma_fence *amdgpu_sync_get_fence(struct amdgpu_sync *sync)
 {
        struct amdgpu_sync_entry *e;
        struct hlist_node *tmp;
-        struct fence *f;
+        struct dma_fence *f;
        int i;
        hash_for_each_safe(sync->fences, i, tmp, e, node) {
@@ -288,10 +290,10 @@ struct fence *amdgpu_sync_get_fence(struct amdgpu_sync *sync)
                hash_del(&e->node);
                kmem_cache_free(amdgpu_sync_slab, e);
-                if (!fence_is_signaled(f))
+                if (!dma_fence_is_signaled(f))
                        return f;
-                fence_put(f);
+                dma_fence_put(f);
        }
        return NULL;
 }
@@ -311,11 +313,11 @@ void amdgpu_sync_free(struct amdgpu_sync *sync)
        hash_for_each_safe(sync->fences, i, tmp, e, node) {
                hash_del(&e->node);
-                fence_put(e->fence);
+                dma_fence_put(e->fence);
                kmem_cache_free(amdgpu_sync_slab, e);
        }
-        fence_put(sync->last_vm_update);
+        dma_fence_put(sync->last_vm_update);
 }
 /**
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_test.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_test.c
index b827c75e95de..e05a24325eeb 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_test.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_test.c
@@ -78,7 +78,7 @@ static void amdgpu_do_test_moves(struct amdgpu_device *adev)
                void *gtt_map, *vram_map;
                void **gtt_start, **gtt_end;
                void **vram_start, **vram_end;
-                struct fence *fence = NULL;
+                struct dma_fence *fence = NULL;
                r = amdgpu_bo_create(adev, size, PAGE_SIZE, true,
                                     AMDGPU_GEM_DOMAIN_GTT, 0, NULL,
@@ -118,13 +118,13 @@ static void amdgpu_do_test_moves(struct amdgpu_device *adev)
                        goto out_lclean_unpin;
                }
-                r = fence_wait(fence, false);
+                r = dma_fence_wait(fence, false);
                if (r) {
                        DRM_ERROR("Failed to wait for GTT->VRAM fence %d\n", i);
                        goto out_lclean_unpin;
                }
-                fence_put(fence);
+                dma_fence_put(fence);
                r = amdgpu_bo_kmap(vram_obj, &vram_map);
                if (r) {
@@ -163,13 +163,13 @@ static void amdgpu_do_test_moves(struct amdgpu_device *adev)
                        goto out_lclean_unpin;
                }
-                r = fence_wait(fence, false);
+                r = dma_fence_wait(fence, false);
                if (r) {
                        DRM_ERROR("Failed to wait for VRAM->GTT fence %d\n", i);
                        goto out_lclean_unpin;
                }
-                fence_put(fence);
+                dma_fence_put(fence);
                r = amdgpu_bo_kmap(gtt_obj[i], &gtt_map);
                if (r) {
@@ -216,7 +216,7 @@ out_lclean:
                        amdgpu_bo_unref(&gtt_obj[i]);
                }
                if (fence)
-                        fence_put(fence);
+                        dma_fence_put(fence);
                break;
        }
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_trace.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_trace.h
index 067e5e683bb3..bb964a8ff938 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_trace.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_trace.h
@@ -104,7 +104,7 @@ TRACE_EVENT(amdgpu_cs_ioctl,
                             __field(struct amdgpu_device *, adev)
                             __field(struct amd_sched_job *, sched_job)
                             __field(struct amdgpu_ib *, ib)
-                             __field(struct fence *, fence)
+                             __field(struct dma_fence *, fence)
                             __field(char *, ring_name)
                             __field(u32, num_ibs)
                             ),
@@ -129,7 +129,7 @@ TRACE_EVENT(amdgpu_sched_run_job,
                             __field(struct amdgpu_device *, adev)
                             __field(struct amd_sched_job *, sched_job)
                             __field(struct amdgpu_ib *, ib)
-                             __field(struct fence *, fence)
+                             __field(struct dma_fence *, fence)
                             __field(char *, ring_name)
                             __field(u32, num_ibs)
                             ),
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c
index dcaf691f56b5..a743aeabc767 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c
@@ -268,7 +268,7 @@ static int amdgpu_move_blit(struct ttm_buffer_object *bo,
        struct amdgpu_device *adev;
        struct amdgpu_ring *ring;
        uint64_t old_start, new_start;
-        struct fence *fence;
+        struct dma_fence *fence;
        int r;
        adev = amdgpu_get_adev(bo->bdev);
@@ -316,7 +316,7 @@ static int amdgpu_move_blit(struct ttm_buffer_object *bo,
                return r;
        r = ttm_bo_pipeline_move(bo, fence, evict, new_mem);
-        fence_put(fence);
+        dma_fence_put(fence);
        return r;
 }
@@ -1247,7 +1247,7 @@ int amdgpu_copy_buffer(struct amdgpu_ring *ring,
                       uint64_t dst_offset,
                       uint32_t byte_count,
                       struct reservation_object *resv,
-                       struct fence **fence, bool direct_submit)
+                       struct dma_fence **fence, bool direct_submit)
 {
        struct amdgpu_device *adev = ring->adev;
        struct amdgpu_job *job;
@@ -1294,7 +1294,7 @@ int amdgpu_copy_buffer(struct amdgpu_ring *ring,
        if (direct_submit) {
                r = amdgpu_ib_schedule(ring, job->num_ibs, job->ibs,
                                       NULL, NULL, fence);
-                job->fence = fence_get(*fence);
+                job->fence = dma_fence_get(*fence);
                if (r)
                        DRM_ERROR("Error scheduling IBs (%d)\n", r);
                amdgpu_job_free(job);
@@ -1315,7 +1315,7 @@ error_free:
 int amdgpu_fill_buffer(struct amdgpu_bo *bo,
                uint32_t src_data,
                struct reservation_object *resv,
-                struct fence **fence)
+                struct dma_fence **fence)
 {
        struct amdgpu_device *adev = bo->adev;
        struct amdgpu_job *job;
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h
index 9812c805326c..3f293e189378 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h
@@ -77,11 +77,11 @@ int amdgpu_copy_buffer(struct amdgpu_ring *ring,
                       uint64_t dst_offset,
                       uint32_t byte_count,
                       struct reservation_object *resv,
-                       struct fence **fence, bool direct_submit);
+                       struct dma_fence **fence, bool direct_submit);
 int amdgpu_fill_buffer(struct amdgpu_bo *bo,
                        uint32_t src_data,
                        struct reservation_object *resv,
-                        struct fence **fence);
+                        struct dma_fence **fence);
 int amdgpu_mmap(struct file *filp, struct vm_area_struct *vma);
 bool amdgpu_ttm_is_bound(struct ttm_tt *ttm);
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_uvd.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_uvd.c
index e3281cacc586..0f6575e7ef8c 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_uvd.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_uvd.c
@@ -333,7 +333,7 @@ void amdgpu_uvd_free_handles(struct amdgpu_device *adev, struct drm_file *filp)
        for (i = 0; i < adev->uvd.max_handles; ++i) {
                uint32_t handle = atomic_read(&adev->uvd.handles[i]);
                if (handle != 0 && adev->uvd.filp[i] == filp) {
-                        struct fence *fence;
+                        struct dma_fence *fence;
                        r = amdgpu_uvd_get_destroy_msg(ring, handle,
                                                       false, &fence);
@@ -342,8 +342,8 @@ void amdgpu_uvd_free_handles(struct amdgpu_device *adev, struct drm_file *filp)
                                continue;
                        }
-                        fence_wait(fence, false);
+                        dma_fence_wait(fence, false);
-                        fence_put(fence);
+                        dma_fence_put(fence);
                        adev->uvd.filp[i] = NULL;
                        atomic_set(&adev->uvd.handles[i], 0);
@@ -909,14 +909,14 @@ int amdgpu_uvd_ring_parse_cs(struct amdgpu_cs_parser *parser, uint32_t ib_idx)
 }
 static int amdgpu_uvd_send_msg(struct amdgpu_ring *ring, struct amdgpu_bo *bo,
-                               bool direct, struct fence **fence)
+                               bool direct, struct dma_fence **fence)
 {
        struct ttm_validate_buffer tv;
        struct ww_acquire_ctx ticket;
        struct list_head head;
        struct amdgpu_job *job;
        struct amdgpu_ib *ib;
-        struct fence *f = NULL;
+        struct dma_fence *f = NULL;
        struct amdgpu_device *adev = ring->adev;
        uint64_t addr;
        int i, r;
@@ -960,7 +960,7 @@ static int amdgpu_uvd_send_msg(struct amdgpu_ring *ring, struct amdgpu_bo *bo,
        if (direct) {
                r = amdgpu_ib_schedule(ring, 1, ib, NULL, NULL, &f);
-                job->fence = fence_get(f);
+                job->fence = dma_fence_get(f);
                if (r)
                        goto err_free;
@@ -975,9 +975,9 @@ static int amdgpu_uvd_send_msg(struct amdgpu_ring *ring, struct amdgpu_bo *bo,
        ttm_eu_fence_buffer_objects(&ticket, &head, f);
        if (fence)
-                *fence = fence_get(f);
+                *fence = dma_fence_get(f);
        amdgpu_bo_unref(&bo);
-        fence_put(f);
+        dma_fence_put(f);
        return 0;
@@ -993,7 +993,7 @@ err:
   crash the vcpu so just try to emmit a dummy create/destroy msg to
   avoid this */
 int amdgpu_uvd_get_create_msg(struct amdgpu_ring *ring, uint32_t handle,
-                              struct fence **fence)
+                              struct dma_fence **fence)
 {
        struct amdgpu_device *adev = ring->adev;
        struct amdgpu_bo *bo;
@@ -1042,7 +1042,7 @@ int amdgpu_uvd_get_create_msg(struct amdgpu_ring *ring, uint32_t handle,
 }
 int amdgpu_uvd_get_destroy_msg(struct amdgpu_ring *ring, uint32_t handle,
-                               bool direct, struct fence **fence)
+                               bool direct, struct dma_fence **fence)
 {
        struct amdgpu_device *adev = ring->adev;
        struct amdgpu_bo *bo;
@@ -1128,7 +1128,7 @@ void amdgpu_uvd_ring_end_use(struct amdgpu_ring *ring)
 */
 int amdgpu_uvd_ring_test_ib(struct amdgpu_ring *ring, long timeout)
 {
-        struct fence *fence;
+        struct dma_fence *fence;
        long r;
        r = amdgpu_uvd_get_create_msg(ring, 1, NULL);
@@ -1143,7 +1143,7 @@ int amdgpu_uvd_ring_test_ib(struct amdgpu_ring *ring, long timeout)
                goto error;
        }
-        r = fence_wait_timeout(fence, false, timeout);
+        r = dma_fence_wait_timeout(fence, false, timeout);
        if (r == 0) {
                DRM_ERROR("amdgpu: IB test timed out.\n");
                r = -ETIMEDOUT;
@@ -1154,7 +1154,7 @@ int amdgpu_uvd_ring_test_ib(struct amdgpu_ring *ring, long timeout)
                r = 0;
        }
-        fence_put(fence);
+        dma_fence_put(fence);
 error:
        return r;
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_uvd.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_uvd.h
index c850009602d1..6249ba1bde2a 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_uvd.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_uvd.h
@@ -29,9 +29,9 @@ int amdgpu_uvd_sw_fini(struct amdgpu_device *adev);
 int amdgpu_uvd_suspend(struct amdgpu_device *adev);
 int amdgpu_uvd_resume(struct amdgpu_device *adev);
 int amdgpu_uvd_get_create_msg(struct amdgpu_ring *ring, uint32_t handle,
-                              struct fence **fence);
+                              struct dma_fence **fence);
 int amdgpu_uvd_get_destroy_msg(struct amdgpu_ring *ring, uint32_t handle,
-                               bool direct, struct fence **fence);
+                               bool direct, struct dma_fence **fence);
 void amdgpu_uvd_free_handles(struct amdgpu_device *adev,
                             struct drm_file *filp);
 int amdgpu_uvd_ring_parse_cs(struct amdgpu_cs_parser *parser, uint32_t ib_idx);
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.c
index 7fe8fd884f06..f0f8afb85585 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.c
@@ -395,12 +395,12 @@ void amdgpu_vce_free_handles(struct amdgpu_device *adev, struct drm_file *filp)
 * Open up a stream for HW test
 */
 int amdgpu_vce_get_create_msg(struct amdgpu_ring *ring, uint32_t handle,
-                              struct fence **fence)
+                              struct dma_fence **fence)
 {
        const unsigned ib_size_dw = 1024;
        struct amdgpu_job *job;
        struct amdgpu_ib *ib;
-        struct fence *f = NULL;
+        struct dma_fence *f = NULL;
        uint64_t dummy;
        int i, r;
@@ -450,14 +450,14 @@ int amdgpu_vce_get_create_msg(struct amdgpu_ring *ring, uint32_t handle,
                ib->ptr[i] = 0x0;
        r = amdgpu_ib_schedule(ring, 1, ib, NULL, NULL, &f);
-        job->fence = fence_get(f);
+        job->fence = dma_fence_get(f);
        if (r)
                goto err;
        amdgpu_job_free(job);
        if (fence)
-                *fence = fence_get(f);
+                *fence = dma_fence_get(f);
-        fence_put(f);
+        dma_fence_put(f);
        return 0;
 err:
@@ -476,12 +476,12 @@ err:
 * Close up a stream for HW test or if userspace failed to do so
 */
 int amdgpu_vce_get_destroy_msg(struct amdgpu_ring *ring, uint32_t handle,
-                               bool direct, struct fence **fence)
+                               bool direct, struct dma_fence **fence)
 {
        const unsigned ib_size_dw = 1024;
        struct amdgpu_job *job;
        struct amdgpu_ib *ib;
-        struct fence *f = NULL;
+        struct dma_fence *f = NULL;
        int i, r;
        r = amdgpu_job_alloc_with_ib(ring->adev, ib_size_dw * 4, &job);
@@ -513,7 +513,7 @@ int amdgpu_vce_get_destroy_msg(struct amdgpu_ring *ring, uint32_t handle,
        if (direct) {
                r = amdgpu_ib_schedule(ring, 1, ib, NULL, NULL, &f);
-                job->fence = fence_get(f);
+                job->fence = dma_fence_get(f);
                if (r)
                        goto err;
@@ -526,8 +526,8 @@ int amdgpu_vce_get_destroy_msg(struct amdgpu_ring *ring, uint32_t handle,
        }
        if (fence)
-                *fence = fence_get(f);
+                *fence = dma_fence_get(f);
-        fence_put(f);
+        dma_fence_put(f);
        return 0;
 err:
@@ -883,7 +883,7 @@ int amdgpu_vce_ring_test_ring(struct amdgpu_ring *ring)
 */
 int amdgpu_vce_ring_test_ib(struct amdgpu_ring *ring, long timeout)
 {
-        struct fence *fence = NULL;
+        struct dma_fence *fence = NULL;
        long r;
        /* skip vce ring1/2 ib test for now, since it's not reliable */
@@ -902,7 +902,7 @@ int amdgpu_vce_ring_test_ib(struct amdgpu_ring *ring, long timeout)
                goto error;
        }
-        r = fence_wait_timeout(fence, false, timeout);
+        r = dma_fence_wait_timeout(fence, false, timeout);
        if (r == 0) {
                DRM_ERROR("amdgpu: IB test timed out.\n");
                r = -ETIMEDOUT;
@@ -913,6 +913,6 @@ int amdgpu_vce_ring_test_ib(struct amdgpu_ring *ring, long timeout)
                r = 0;
        }
 error:
-        fence_put(fence);
+        dma_fence_put(fence);
        return r;
 }
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.h
index 12729d2852df..566c29ddeeb6 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.h
@@ -29,9 +29,9 @@ int amdgpu_vce_sw_fini(struct amdgpu_device *adev);
 int amdgpu_vce_suspend(struct amdgpu_device *adev);
 int amdgpu_vce_resume(struct amdgpu_device *adev);
 int amdgpu_vce_get_create_msg(struct amdgpu_ring *ring, uint32_t handle,
-                              struct fence **fence);
+                              struct dma_fence **fence);
 int amdgpu_vce_get_destroy_msg(struct amdgpu_ring *ring, uint32_t handle,
-                               bool direct, struct fence **fence);
+                               bool direct, struct dma_fence **fence);
 void amdgpu_vce_free_handles(struct amdgpu_device *adev, struct drm_file *filp);
 int amdgpu_vce_ring_parse_cs(struct amdgpu_cs_parser *p, uint32_t ib_idx);
 void amdgpu_vce_ring_emit_ib(struct amdgpu_ring *ring, struct amdgpu_ib *ib,
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
index 06f24322e7c3..22cabb5456e0 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
@@ -25,7 +25,7 @@
 *          Alex Deucher
 *          Jerome Glisse
 */
-#include <linux/fence-array.h>
+#include <linux/dma-fence-array.h>
 #include <drm/drmP.h>
 #include <drm/amdgpu_drm.h>
 #include "amdgpu.h"
@@ -194,14 +194,14 @@ static bool amdgpu_vm_is_gpu_reset(struct amdgpu_device *adev,
 * Allocate an id for the vm, adding fences to the sync obj as necessary.
 */
 int amdgpu_vm_grab_id(struct amdgpu_vm *vm, struct amdgpu_ring *ring,
-                      struct amdgpu_sync *sync, struct fence *fence,
+                      struct amdgpu_sync *sync, struct dma_fence *fence,
                      struct amdgpu_job *job)
 {
        struct amdgpu_device *adev = ring->adev;
        uint64_t fence_context = adev->fence_context + ring->idx;
-        struct fence *updates = sync->last_vm_update;
+        struct dma_fence *updates = sync->last_vm_update;
        struct amdgpu_vm_id *id, *idle;
-        struct fence **fences;
+        struct dma_fence **fences;
        unsigned i;
        int r = 0;
@@ -225,17 +225,17 @@ int amdgpu_vm_grab_id(struct amdgpu_vm *vm, struct amdgpu_ring *ring,
        if (&idle->list == &adev->vm_manager.ids_lru) {
                u64 fence_context = adev->vm_manager.fence_context + ring->idx;
                unsigned seqno = ++adev->vm_manager.seqno[ring->idx];
-                struct fence_array *array;
+                struct dma_fence_array *array;
                unsigned j;
                for (j = 0; j < i; ++j)
-                        fence_get(fences[j]);
+                        dma_fence_get(fences[j]);
-                array = fence_array_create(i, fences, fence_context,
+                array = dma_fence_array_create(i, fences, fence_context,
                                           seqno, true);
                if (!array) {
                        for (j = 0; j < i; ++j)
-                                fence_put(fences[j]);
+                                dma_fence_put(fences[j]);
                        kfree(fences);
                        r = -ENOMEM;
                        goto error;
@@ -243,7 +243,7 @@ int amdgpu_vm_grab_id(struct amdgpu_vm *vm, struct amdgpu_ring *ring,
                r = amdgpu_sync_fence(ring->adev, sync, &array->base);
-                fence_put(&array->base);
+                dma_fence_put(&array->base);
                if (r)
                        goto error;
@@ -257,7 +257,7 @@ int amdgpu_vm_grab_id(struct amdgpu_vm *vm, struct amdgpu_ring *ring,
        /* Check if we can use a VMID already assigned to this VM */
        i = ring->idx;
        do {
-                struct fence *flushed;
+                struct dma_fence *flushed;
                id = vm->ids[i++];
                if (i == AMDGPU_MAX_RINGS)
@@ -279,12 +279,12 @@ int amdgpu_vm_grab_id(struct amdgpu_vm *vm, struct amdgpu_ring *ring,
                        continue;
                if (id->last_flush->context != fence_context &&
-                    !fence_is_signaled(id->last_flush))
+                    !dma_fence_is_signaled(id->last_flush))
                        continue;
                flushed  = id->flushed_updates;
                if (updates &&
-                    (!flushed || fence_is_later(updates, flushed)))
+                    (!flushed || dma_fence_is_later(updates, flushed)))
                        continue;
                /* Good we can use this VMID. Remember this submission as
@@ -315,14 +315,14 @@ int amdgpu_vm_grab_id(struct amdgpu_vm *vm, struct amdgpu_ring *ring,
        if (r)
                goto error;
-        fence_put(id->first);
+        dma_fence_put(id->first);
-        id->first = fence_get(fence);
+        id->first = dma_fence_get(fence);
-        fence_put(id->last_flush);
+        dma_fence_put(id->last_flush);
        id->last_flush = NULL;
-        fence_put(id->flushed_updates);
+        dma_fence_put(id->flushed_updates);
-        id->flushed_updates = fence_get(updates);
+        id->flushed_updates = dma_fence_get(updates);
        id->pd_gpu_addr = job->vm_pd_addr;
        id->current_gpu_reset_count = atomic_read(&adev->gpu_reset_counter);
@@ -393,7 +393,7 @@ int amdgpu_vm_flush(struct amdgpu_ring *ring, struct amdgpu_job *job)
        if (ring->funcs->emit_vm_flush && (job->vm_needs_flush ||
            amdgpu_vm_is_gpu_reset(adev, id))) {
-                struct fence *fence;
+                struct dma_fence *fence;
                trace_amdgpu_vm_flush(job->vm_pd_addr, ring->idx, job->vm_id);
                amdgpu_ring_emit_vm_flush(ring, job->vm_id, job->vm_pd_addr);
@@ -403,7 +403,7 @@ int amdgpu_vm_flush(struct amdgpu_ring *ring, struct amdgpu_job *job)
                        return r;
                mutex_lock(&adev->vm_manager.lock);
-                fence_put(id->last_flush);
+                dma_fence_put(id->last_flush);
                id->last_flush = fence;
                mutex_unlock(&adev->vm_manager.lock);
        }
@@ -537,7 +537,7 @@ static int amdgpu_vm_clear_bo(struct amdgpu_device *adev,
                              struct amdgpu_bo *bo)
 {
        struct amdgpu_ring *ring;
-        struct fence *fence = NULL;
+        struct dma_fence *fence = NULL;
        struct amdgpu_job *job;
        struct amdgpu_pte_update_params params;
        unsigned entries;
@@ -578,7 +578,7 @@ static int amdgpu_vm_clear_bo(struct amdgpu_device *adev,
                goto error_free;
        amdgpu_bo_fence(bo, fence, true);
-        fence_put(fence);
+        dma_fence_put(fence);
        return 0;
 error_free:
@@ -625,7 +625,7 @@ static int amdgpu_vm_update_pd_or_shadow(struct amdgpu_device *adev,
        unsigned count = 0, pt_idx, ndw;
        struct amdgpu_job *job;
        struct amdgpu_pte_update_params params;
-        struct fence *fence = NULL;
+        struct dma_fence *fence = NULL;
        int r;
@@ -714,9 +714,9 @@ static int amdgpu_vm_update_pd_or_shadow(struct amdgpu_device *adev,
                        goto error_free;
                amdgpu_bo_fence(pd, fence, true);
-                fence_put(vm->page_directory_fence);
+                dma_fence_put(vm->page_directory_fence);
-                vm->page_directory_fence = fence_get(fence);
+                vm->page_directory_fence = dma_fence_get(fence);
-                fence_put(fence);
+                dma_fence_put(fence);
        } else {
                amdgpu_job_free(job);
@@ -929,20 +929,20 @@ static void amdgpu_vm_frag_ptes(struct amdgpu_pte_update_params	*params,
 * Returns 0 for success, -EINVAL for failure.
 */
 static int amdgpu_vm_bo_update_mapping(struct amdgpu_device *adev,
-                                       struct fence *exclusive,
+                                       struct dma_fence *exclusive,
                                       uint64_t src,
                                       dma_addr_t *pages_addr,
                                       struct amdgpu_vm *vm,
                                       uint64_t start, uint64_t last,
                                       uint32_t flags, uint64_t addr,
-                                       struct fence **fence)
+                                       struct dma_fence **fence)
 {
        struct amdgpu_ring *ring;
        void *owner = AMDGPU_FENCE_OWNER_VM;
        unsigned nptes, ncmds, ndw;
        struct amdgpu_job *job;
        struct amdgpu_pte_update_params params;
-        struct fence *f = NULL;
+        struct dma_fence *f = NULL;
        int r;
        memset(&params, 0, sizeof(params));
@@ -1045,10 +1045,10 @@ static int amdgpu_vm_bo_update_mapping(struct amdgpu_device *adev,
        amdgpu_bo_fence(vm->page_directory, f, true);
        if (fence) {
-                fence_put(*fence);
+                dma_fence_put(*fence);
-                *fence = fence_get(f);
+                *fence = dma_fence_get(f);
        }
-        fence_put(f);
+        dma_fence_put(f);
        return 0;
 error_free:
@@ -1074,13 +1074,13 @@ error_free:
 * Returns 0 for success, -EINVAL for failure.
 */
 static int amdgpu_vm_bo_split_mapping(struct amdgpu_device *adev,
-                                      struct fence *exclusive,
+                                      struct dma_fence *exclusive,
                                      uint32_t gtt_flags,
                                      dma_addr_t *pages_addr,
                                      struct amdgpu_vm *vm,
                                      struct amdgpu_bo_va_mapping *mapping,
                                      uint32_t flags, uint64_t addr,
-                                      struct fence **fence)
+                                      struct dma_fence **fence)
 {
        const uint64_t max_size = 64ULL * 1024ULL * 1024ULL / AMDGPU_GPU_PAGE_SIZE;
@@ -1147,7 +1147,7 @@ int amdgpu_vm_bo_update(struct amdgpu_device *adev,
        dma_addr_t *pages_addr = NULL;
        uint32_t gtt_flags, flags;
        struct ttm_mem_reg *mem;
-        struct fence *exclusive;
+        struct dma_fence *exclusive;
        uint64_t addr;
        int r;
@@ -1547,7 +1547,7 @@ void amdgpu_vm_bo_rmv(struct amdgpu_device *adev,
                kfree(mapping);
        }
-        fence_put(bo_va->last_pt_update);
+        dma_fence_put(bo_va->last_pt_update);
        kfree(bo_va);
 }
@@ -1709,7 +1709,7 @@ void amdgpu_vm_fini(struct amdgpu_device *adev, struct amdgpu_vm *vm)
        amdgpu_bo_unref(&vm->page_directory->shadow);
        amdgpu_bo_unref(&vm->page_directory);
-        fence_put(vm->page_directory_fence);
+        dma_fence_put(vm->page_directory_fence);
 }
 /**
@@ -1733,7 +1733,8 @@ void amdgpu_vm_manager_init(struct amdgpu_device *adev)
                              &adev->vm_manager.ids_lru);
        }
-        adev->vm_manager.fence_context = fence_context_alloc(AMDGPU_MAX_RINGS);
+        adev->vm_manager.fence_context =
+                dma_fence_context_alloc(AMDGPU_MAX_RINGS);
        for (i = 0; i < AMDGPU_MAX_RINGS; ++i)
                adev->vm_manager.seqno[i] = 0;
@@ -1755,8 +1756,8 @@ void amdgpu_vm_manager_fini(struct amdgpu_device *adev)
        for (i = 0; i < AMDGPU_NUM_VM; ++i) {
                struct amdgpu_vm_id *id = &adev->vm_manager.ids[i];
-                fence_put(adev->vm_manager.ids[i].first);
+                dma_fence_put(adev->vm_manager.ids[i].first);
                amdgpu_sync_free(&adev->vm_manager.ids[i].active);
-                fence_put(id->flushed_updates);
+                dma_fence_put(id->flushed_updates);
        }
 }
diff --git a/drivers/gpu/drm/amd/amdgpu/cik_sdma.c b/drivers/gpu/drm/amd/amdgpu/cik_sdma.c
index cb952acc7133..321b9d5a4e6e 100644
--- a/drivers/gpu/drm/amd/amdgpu/cik_sdma.c
+++ b/drivers/gpu/drm/amd/amdgpu/cik_sdma.c
@@ -622,7 +622,7 @@ static int cik_sdma_ring_test_ib(struct amdgpu_ring *ring, long timeout)
 {
        struct amdgpu_device *adev = ring->adev;
        struct amdgpu_ib ib;
-        struct fence *f = NULL;
+        struct dma_fence *f = NULL;
        unsigned index;
        u32 tmp = 0;
        u64 gpu_addr;
@@ -655,7 +655,7 @@ static int cik_sdma_ring_test_ib(struct amdgpu_ring *ring, long timeout)
        if (r)
                goto err1;
-        r = fence_wait_timeout(f, false, timeout);
+        r = dma_fence_wait_timeout(f, false, timeout);
        if (r == 0) {
                DRM_ERROR("amdgpu: IB test timed out\n");
                r = -ETIMEDOUT;
@@ -675,7 +675,7 @@ static int cik_sdma_ring_test_ib(struct amdgpu_ring *ring, long timeout)
 err1:
        amdgpu_ib_free(adev, &ib, NULL);
-        fence_put(f);
+        dma_fence_put(f);
 err0:
        amdgpu_wb_free(adev, index);
        return r;
diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v6_0.c b/drivers/gpu/drm/amd/amdgpu/gfx_v6_0.c
index 40abb6b81c09..7dc11a19e49d 100644
--- a/drivers/gpu/drm/amd/amdgpu/gfx_v6_0.c
+++ b/drivers/gpu/drm/amd/amdgpu/gfx_v6_0.c
@@ -1522,7 +1522,7 @@ static int gfx_v6_0_ring_test_ib(struct amdgpu_ring *ring, long timeout)
 {
        struct amdgpu_device *adev = ring->adev;
        struct amdgpu_ib ib;
-        struct fence *f = NULL;
+        struct dma_fence *f = NULL;
        uint32_t scratch;
        uint32_t tmp = 0;
        long r;
@@ -1548,7 +1548,7 @@ static int gfx_v6_0_ring_test_ib(struct amdgpu_ring *ring, long timeout)
        if (r)
                goto err2;
-        r = fence_wait_timeout(f, false, timeout);
+        r = dma_fence_wait_timeout(f, false, timeout);
        if (r == 0) {
                DRM_ERROR("amdgpu: IB test timed out\n");
                r = -ETIMEDOUT;
@@ -1569,7 +1569,7 @@ static int gfx_v6_0_ring_test_ib(struct amdgpu_ring *ring, long timeout)
 err2:
        amdgpu_ib_free(adev, &ib, NULL);
-        fence_put(f);
+        dma_fence_put(f);
 err1:
        amdgpu_gfx_scratch_free(adev, scratch);
        return r;
diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v7_0.c b/drivers/gpu/drm/amd/amdgpu/gfx_v7_0.c
index 71116da9e782..3865ffe7de55 100644
--- a/drivers/gpu/drm/amd/amdgpu/gfx_v7_0.c
+++ b/drivers/gpu/drm/amd/amdgpu/gfx_v7_0.c
@@ -2286,7 +2286,7 @@ static int gfx_v7_0_ring_test_ib(struct amdgpu_ring *ring, long timeout)
 {
        struct amdgpu_device *adev = ring->adev;
        struct amdgpu_ib ib;
-        struct fence *f = NULL;
+        struct dma_fence *f = NULL;
        uint32_t scratch;
        uint32_t tmp = 0;
        long r;
@@ -2312,7 +2312,7 @@ static int gfx_v7_0_ring_test_ib(struct amdgpu_ring *ring, long timeout)
        if (r)
                goto err2;
-        r = fence_wait_timeout(f, false, timeout);
+        r = dma_fence_wait_timeout(f, false, timeout);
        if (r == 0) {
                DRM_ERROR("amdgpu: IB test timed out\n");
                r = -ETIMEDOUT;
@@ -2333,7 +2333,7 @@ static int gfx_v7_0_ring_test_ib(struct amdgpu_ring *ring, long timeout)
 err2:
        amdgpu_ib_free(adev, &ib, NULL);
-        fence_put(f);
+        dma_fence_put(f);
 err1:
        amdgpu_gfx_scratch_free(adev, scratch);
        return r;
diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c b/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c
index ee6a48a09214..a9dd18847c40 100644
--- a/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c
+++ b/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c
@@ -798,7 +798,7 @@ static int gfx_v8_0_ring_test_ib(struct amdgpu_ring *ring, long timeout)
 {
        struct amdgpu_device *adev = ring->adev;
        struct amdgpu_ib ib;
-        struct fence *f = NULL;
+        struct dma_fence *f = NULL;
        uint32_t scratch;
        uint32_t tmp = 0;
        long r;
@@ -824,7 +824,7 @@ static int gfx_v8_0_ring_test_ib(struct amdgpu_ring *ring, long timeout)
        if (r)
                goto err2;
-        r = fence_wait_timeout(f, false, timeout);
+        r = dma_fence_wait_timeout(f, false, timeout);
        if (r == 0) {
                DRM_ERROR("amdgpu: IB test timed out.\n");
                r = -ETIMEDOUT;
@@ -844,7 +844,7 @@ static int gfx_v8_0_ring_test_ib(struct amdgpu_ring *ring, long timeout)
        }
 err2:
        amdgpu_ib_free(adev, &ib, NULL);
-        fence_put(f);
+        dma_fence_put(f);
 err1:
        amdgpu_gfx_scratch_free(adev, scratch);
        return r;
@@ -1575,7 +1575,7 @@ static int gfx_v8_0_do_edc_gpr_workarounds(struct amdgpu_device *adev)
 {
        struct amdgpu_ring *ring = &adev->gfx.compute_ring[0];
        struct amdgpu_ib ib;
-        struct fence *f = NULL;
+        struct dma_fence *f = NULL;
        int r, i;
        u32 tmp;
        unsigned total_size, vgpr_offset, sgpr_offset;
@@ -1708,7 +1708,7 @@ static int gfx_v8_0_do_edc_gpr_workarounds(struct amdgpu_device *adev)
        }
        /* wait for the GPU to finish processing the IB */
-        r = fence_wait(f, false);
+        r = dma_fence_wait(f, false);
        if (r) {
                DRM_ERROR("amdgpu: fence wait failed (%d).\n", r);
                goto fail;
@@ -1729,7 +1729,7 @@ static int gfx_v8_0_do_edc_gpr_workarounds(struct amdgpu_device *adev)
 fail:
        amdgpu_ib_free(adev, &ib, NULL);
-        fence_put(f);
+        dma_fence_put(f);
        return r;
 }
diff --git a/drivers/gpu/drm/amd/amdgpu/sdma_v2_4.c b/drivers/gpu/drm/amd/amdgpu/sdma_v2_4.c
index 565dab3c7218..7edf6e8c63dc 100644
--- a/drivers/gpu/drm/amd/amdgpu/sdma_v2_4.c
+++ b/drivers/gpu/drm/amd/amdgpu/sdma_v2_4.c
@@ -668,7 +668,7 @@ static int sdma_v2_4_ring_test_ib(struct amdgpu_ring *ring, long timeout)
 {
        struct amdgpu_device *adev = ring->adev;
        struct amdgpu_ib ib;
-        struct fence *f = NULL;
+        struct dma_fence *f = NULL;
        unsigned index;
        u32 tmp = 0;
        u64 gpu_addr;
@@ -705,7 +705,7 @@ static int sdma_v2_4_ring_test_ib(struct amdgpu_ring *ring, long timeout)
        if (r)
                goto err1;
-        r = fence_wait_timeout(f, false, timeout);
+        r = dma_fence_wait_timeout(f, false, timeout);
        if (r == 0) {
                DRM_ERROR("amdgpu: IB test timed out\n");
                r = -ETIMEDOUT;
@@ -725,7 +725,7 @@ static int sdma_v2_4_ring_test_ib(struct amdgpu_ring *ring, long timeout)
 err1:
        amdgpu_ib_free(adev, &ib, NULL);
-        fence_put(f);
+        dma_fence_put(f);
 err0:
        amdgpu_wb_free(adev, index);
        return r;
diff --git a/drivers/gpu/drm/amd/amdgpu/sdma_v3_0.c b/drivers/gpu/drm/amd/amdgpu/sdma_v3_0.c
index a9d10941fb53..1932a67c62ef 100644
--- a/drivers/gpu/drm/amd/amdgpu/sdma_v3_0.c
+++ b/drivers/gpu/drm/amd/amdgpu/sdma_v3_0.c
@@ -871,7 +871,7 @@ static int sdma_v3_0_ring_test_ib(struct amdgpu_ring *ring, long timeout)
 {
        struct amdgpu_device *adev = ring->adev;
        struct amdgpu_ib ib;
-        struct fence *f = NULL;
+        struct dma_fence *f = NULL;
        unsigned index;
        u32 tmp = 0;
        u64 gpu_addr;
@@ -908,7 +908,7 @@ static int sdma_v3_0_ring_test_ib(struct amdgpu_ring *ring, long timeout)
        if (r)
                goto err1;
-        r = fence_wait_timeout(f, false, timeout);
+        r = dma_fence_wait_timeout(f, false, timeout);
        if (r == 0) {
                DRM_ERROR("amdgpu: IB test timed out\n");
                r = -ETIMEDOUT;
@@ -927,7 +927,7 @@ static int sdma_v3_0_ring_test_ib(struct amdgpu_ring *ring, long timeout)
        }
 err1:
        amdgpu_ib_free(adev, &ib, NULL);
-        fence_put(f);
+        dma_fence_put(f);
 err0:
        amdgpu_wb_free(adev, index);
        return r;
diff --git a/drivers/gpu/drm/amd/amdgpu/si_dma.c b/drivers/gpu/drm/amd/amdgpu/si_dma.c
index de358193a8f9..b4cf4e25bf91 100644
--- a/drivers/gpu/drm/amd/amdgpu/si_dma.c
+++ b/drivers/gpu/drm/amd/amdgpu/si_dma.c
@@ -274,7 +274,7 @@ static int si_dma_ring_test_ib(struct amdgpu_ring *ring, long timeout)
 {
        struct amdgpu_device *adev = ring->adev;
        struct amdgpu_ib ib;
-        struct fence *f = NULL;
+        struct dma_fence *f = NULL;
        unsigned index;
        u32 tmp = 0;
        u64 gpu_addr;
@@ -305,7 +305,7 @@ static int si_dma_ring_test_ib(struct amdgpu_ring *ring, long timeout)
        if (r)
                goto err1;
-        r = fence_wait_timeout(f, false, timeout);
+        r = dma_fence_wait_timeout(f, false, timeout);
        if (r == 0) {
                DRM_ERROR("amdgpu: IB test timed out\n");
                r = -ETIMEDOUT;
@@ -325,7 +325,7 @@ static int si_dma_ring_test_ib(struct amdgpu_ring *ring, long timeout)
 err1:
        amdgpu_ib_free(adev, &ib, NULL);
-        fence_put(f);
+        dma_fence_put(f);
 err0:
        amdgpu_wb_free(adev, index);
        return r;
diff --git a/drivers/gpu/drm/amd/scheduler/gpu_sched_trace.h b/drivers/gpu/drm/amd/scheduler/gpu_sched_trace.h
index b961a1c6caf3..dbd4fd3a810b 100644
--- a/drivers/gpu/drm/amd/scheduler/gpu_sched_trace.h
+++ b/drivers/gpu/drm/amd/scheduler/gpu_sched_trace.h
@@ -17,7 +17,7 @@ TRACE_EVENT(amd_sched_job,
            TP_STRUCT__entry(
                             __field(struct amd_sched_entity *, entity)
                             __field(struct amd_sched_job *, sched_job)
-                             __field(struct fence *, fence)
+                             __field(struct dma_fence *, fence)
                             __field(const char *, name)
                             __field(u32, job_count)
                             __field(int, hw_job_count)
@@ -42,7 +42,7 @@ TRACE_EVENT(amd_sched_process_job,
            TP_PROTO(struct amd_sched_fence *fence),
            TP_ARGS(fence),
            TP_STRUCT__entry(
-                    __field(struct fence *, fence)
+                    __field(struct dma_fence *, fence)
                    ),
            TP_fast_assign(
diff --git a/drivers/gpu/drm/amd/scheduler/gpu_scheduler.c b/drivers/gpu/drm/amd/scheduler/gpu_scheduler.c
index 963a24d46a93..5364e6a7ec8f 100644
--- a/drivers/gpu/drm/amd/scheduler/gpu_scheduler.c
+++ b/drivers/gpu/drm/amd/scheduler/gpu_scheduler.c
@@ -32,7 +32,7 @@
 static bool amd_sched_entity_is_ready(struct amd_sched_entity *entity);
 static void amd_sched_wakeup(struct amd_gpu_scheduler *sched);
-static void amd_sched_process_job(struct fence *f, struct fence_cb *cb);
+static void amd_sched_process_job(struct dma_fence *f, struct dma_fence_cb *cb);
 struct kmem_cache *sched_fence_slab;
 atomic_t sched_fence_slab_ref = ATOMIC_INIT(0);
@@ -141,7 +141,7 @@ int amd_sched_entity_init(struct amd_gpu_scheduler *sched,
                return r;
        atomic_set(&entity->fence_seq, 0);
-        entity->fence_context = fence_context_alloc(2);
+        entity->fence_context = dma_fence_context_alloc(2);
        return 0;
 }
@@ -221,32 +221,32 @@ void amd_sched_entity_fini(struct amd_gpu_scheduler *sched,
        kfifo_free(&entity->job_queue);
 }
-static void amd_sched_entity_wakeup(struct fence *f, struct fence_cb *cb)
+static void amd_sched_entity_wakeup(struct dma_fence *f, struct dma_fence_cb *cb)
 {
        struct amd_sched_entity *entity =
                container_of(cb, struct amd_sched_entity, cb);
        entity->dependency = NULL;
-        fence_put(f);
+        dma_fence_put(f);
        amd_sched_wakeup(entity->sched);
 }
-static void amd_sched_entity_clear_dep(struct fence *f, struct fence_cb *cb)
+static void amd_sched_entity_clear_dep(struct dma_fence *f, struct dma_fence_cb *cb)
 {
        struct amd_sched_entity *entity =
                container_of(cb, struct amd_sched_entity, cb);
        entity->dependency = NULL;
-        fence_put(f);
+        dma_fence_put(f);
 }
 static bool amd_sched_entity_add_dependency_cb(struct amd_sched_entity *entity)
 {
        struct amd_gpu_scheduler *sched = entity->sched;
-        struct fence * fence = entity->dependency;
+        struct dma_fence * fence = entity->dependency;
        struct amd_sched_fence *s_fence;
        if (fence->context == entity->fence_context) {
                /* We can ignore fences from ourself */
-                fence_put(entity->dependency);
+                dma_fence_put(entity->dependency);
                return false;
        }
@@ -257,23 +257,23 @@ static bool amd_sched_entity_add_dependency_cb(struct amd_sched_entity *entity)
                 * Fence is from the same scheduler, only need to wait for
                 * it to be scheduled
                 */
-                fence = fence_get(&s_fence->scheduled);
+                fence = dma_fence_get(&s_fence->scheduled);
-                fence_put(entity->dependency);
+                dma_fence_put(entity->dependency);
                entity->dependency = fence;
-                if (!fence_add_callback(fence, &entity->cb,
+                if (!dma_fence_add_callback(fence, &entity->cb,
-                                        amd_sched_entity_clear_dep))
+                                            amd_sched_entity_clear_dep))
                        return true;
                /* Ignore it when it is already scheduled */
-                fence_put(fence);
+                dma_fence_put(fence);
                return false;
        }
-        if (!fence_add_callback(entity->dependency, &entity->cb,
+        if (!dma_fence_add_callback(entity->dependency, &entity->cb,
-                                amd_sched_entity_wakeup))
+                                    amd_sched_entity_wakeup))
                return true;
-        fence_put(entity->dependency);
+        dma_fence_put(entity->dependency);
        return false;
 }
@@ -354,7 +354,8 @@ static void amd_sched_job_finish(struct work_struct *work)
        sched->ops->free_job(s_job);
 }
-static void amd_sched_job_finish_cb(struct fence *f, struct fence_cb *cb)
+static void amd_sched_job_finish_cb(struct dma_fence *f,
+                                    struct dma_fence_cb *cb)
 {
        struct amd_sched_job *job = container_of(cb, struct amd_sched_job,
                                                 finish_cb);
@@ -388,8 +389,8 @@ void amd_sched_hw_job_reset(struct amd_gpu_scheduler *sched)
        spin_lock(&sched->job_list_lock);
        list_for_each_entry_reverse(s_job, &sched->ring_mirror_list, node) {
-                if (fence_remove_callback(s_job->s_fence->parent, &s_job->s_fence->cb)) {
+                if (dma_fence_remove_callback(s_job->s_fence->parent, &s_job->s_fence->cb)) {
-                        fence_put(s_job->s_fence->parent);
+                        dma_fence_put(s_job->s_fence->parent);
                        s_job->s_fence->parent = NULL;
                }
        }
@@ -410,21 +411,21 @@ void amd_sched_job_recovery(struct amd_gpu_scheduler *sched)
        list_for_each_entry_safe(s_job, tmp, &sched->ring_mirror_list, node) {
                struct amd_sched_fence *s_fence = s_job->s_fence;
-                struct fence *fence;
+                struct dma_fence *fence;
                spin_unlock(&sched->job_list_lock);
                fence = sched->ops->run_job(s_job);
                atomic_inc(&sched->hw_rq_count);
                if (fence) {
-                        s_fence->parent = fence_get(fence);
+                        s_fence->parent = dma_fence_get(fence);
-                        r = fence_add_callback(fence, &s_fence->cb,
+                        r = dma_fence_add_callback(fence, &s_fence->cb,
-                                               amd_sched_process_job);
+                                                   amd_sched_process_job);
                        if (r == -ENOENT)
                                amd_sched_process_job(fence, &s_fence->cb);
                        else if (r)
                                DRM_ERROR("fence add callback failed (%d)\n",
                                          r);
-                        fence_put(fence);
+                        dma_fence_put(fence);
                } else {
                        DRM_ERROR("Failed to run job!\n");
                        amd_sched_process_job(NULL, &s_fence->cb);
@@ -446,8 +447,8 @@ void amd_sched_entity_push_job(struct amd_sched_job *sched_job)
        struct amd_sched_entity *entity = sched_job->s_entity;
        trace_amd_sched_job(sched_job);
-        fence_add_callback(&sched_job->s_fence->finished, &sched_job->finish_cb,
+        dma_fence_add_callback(&sched_job->s_fence->finished, &sched_job->finish_cb,
-                           amd_sched_job_finish_cb);
+                               amd_sched_job_finish_cb);
        wait_event(entity->sched->job_scheduled,
                   amd_sched_entity_in(sched_job));
 }
@@ -511,7 +512,7 @@ amd_sched_select_entity(struct amd_gpu_scheduler *sched)
        return entity;
 }
-static void amd_sched_process_job(struct fence *f, struct fence_cb *cb)
+static void amd_sched_process_job(struct dma_fence *f, struct dma_fence_cb *cb)
 {
        struct amd_sched_fence *s_fence =
                container_of(cb, struct amd_sched_fence, cb);
@@ -521,7 +522,7 @@ static void amd_sched_process_job(struct fence *f, struct fence_cb *cb)
        amd_sched_fence_finished(s_fence);
        trace_amd_sched_process_job(s_fence);
-        fence_put(&s_fence->finished);
+        dma_fence_put(&s_fence->finished);
        wake_up_interruptible(&sched->wake_up_worker);
 }
@@ -547,7 +548,7 @@ static int amd_sched_main(void *param)
                struct amd_sched_entity *entity = NULL;
                struct amd_sched_fence *s_fence;
                struct amd_sched_job *sched_job;
-                struct fence *fence;
+                struct dma_fence *fence;
                wait_event_interruptible(sched->wake_up_worker,
                                         (!amd_sched_blocked(sched) &&
@@ -569,15 +570,15 @@ static int amd_sched_main(void *param)
                fence = sched->ops->run_job(sched_job);
                amd_sched_fence_scheduled(s_fence);
                if (fence) {
-                        s_fence->parent = fence_get(fence);
+                        s_fence->parent = dma_fence_get(fence);
-                        r = fence_add_callback(fence, &s_fence->cb,
+                        r = dma_fence_add_callback(fence, &s_fence->cb,
-                                               amd_sched_process_job);
+                                                   amd_sched_process_job);
                        if (r == -ENOENT)
                                amd_sched_process_job(fence, &s_fence->cb);
                        else if (r)
                                DRM_ERROR("fence add callback failed (%d)\n",
                                          r);
-                        fence_put(fence);
+                        dma_fence_put(fence);
                } else {
                        DRM_ERROR("Failed to run job!\n");
                        amd_sched_process_job(NULL, &s_fence->cb);
diff --git a/drivers/gpu/drm/amd/scheduler/gpu_scheduler.h b/drivers/gpu/drm/amd/scheduler/gpu_scheduler.h
index 7cbbbfb502ef..876aa43b57df 100644
--- a/drivers/gpu/drm/amd/scheduler/gpu_scheduler.h
+++ b/drivers/gpu/drm/amd/scheduler/gpu_scheduler.h
@@ -25,7 +25,7 @@
 #define _GPU_SCHEDULER_H_
 #include <linux/kfifo.h>
-#include <linux/fence.h>
+#include <linux/dma-fence.h>
 struct amd_gpu_scheduler;
 struct amd_sched_rq;
@@ -50,8 +50,8 @@ struct amd_sched_entity {
        atomic_t                        fence_seq;
        uint64_t                        fence_context;
-        struct fence                    *dependency;
+        struct dma_fence                *dependency;
-        struct fence_cb                 cb;
+        struct dma_fence_cb             cb;
 };
 /**
@@ -66,10 +66,10 @@ struct amd_sched_rq {
 };
 struct amd_sched_fence {
-        struct fence                    scheduled;
+        struct dma_fence                scheduled;
-        struct fence                    finished;
+        struct dma_fence                finished;
-        struct fence_cb                 cb;
+        struct dma_fence_cb             cb;
-        struct fence                    *parent;
+        struct dma_fence                *parent;
        struct amd_gpu_scheduler        *sched;
        spinlock_t                      lock;
        void                            *owner;
@@ -79,15 +79,15 @@ struct amd_sched_job {
        struct amd_gpu_scheduler        *sched;
        struct amd_sched_entity         *s_entity;
        struct amd_sched_fence          *s_fence;
-        struct fence_cb                 finish_cb;
+        struct dma_fence_cb             finish_cb;
        struct work_struct              finish_work;
        struct list_head                node;
        struct delayed_work             work_tdr;
 };
-extern const struct fence_ops amd_sched_fence_ops_scheduled;
+extern const struct dma_fence_ops amd_sched_fence_ops_scheduled;
-extern const struct fence_ops amd_sched_fence_ops_finished;
+extern const struct dma_fence_ops amd_sched_fence_ops_finished;
-static inline struct amd_sched_fence *to_amd_sched_fence(struct fence *f)
+static inline struct amd_sched_fence *to_amd_sched_fence(struct dma_fence *f)
 {
        if (f->ops == &amd_sched_fence_ops_scheduled)
                return container_of(f, struct amd_sched_fence, scheduled);
@@ -103,8 +103,8 @@ static inline struct amd_sched_fence *to_amd_sched_fence(struct fence *f)
 * these functions should be implemented in driver side
 */
 struct amd_sched_backend_ops {
-        struct fence *(*dependency)(struct amd_sched_job *sched_job);
+        struct dma_fence *(*dependency)(struct amd_sched_job *sched_job);
-        struct fence *(*run_job)(struct amd_sched_job *sched_job);
+        struct dma_fence *(*run_job)(struct amd_sched_job *sched_job);
        void (*timedout_job)(struct amd_sched_job *sched_job);
        void (*free_job)(struct amd_sched_job *sched_job);
 };
diff --git a/drivers/gpu/drm/amd/scheduler/sched_fence.c b/drivers/gpu/drm/amd/scheduler/sched_fence.c
index 6b63beaf7574..c26fa298fe9e 100644
--- a/drivers/gpu/drm/amd/scheduler/sched_fence.c
+++ b/drivers/gpu/drm/amd/scheduler/sched_fence.c
@@ -42,46 +42,50 @@ struct amd_sched_fence *amd_sched_fence_create(struct amd_sched_entity *entity,
        spin_lock_init(&fence->lock);
        seq = atomic_inc_return(&entity->fence_seq);
-        fence_init(&fence->scheduled, &amd_sched_fence_ops_scheduled,
+        dma_fence_init(&fence->scheduled, &amd_sched_fence_ops_scheduled,
-                   &fence->lock, entity->fence_context, seq);
+                       &fence->lock, entity->fence_context, seq);
-        fence_init(&fence->finished, &amd_sched_fence_ops_finished,
+        dma_fence_init(&fence->finished, &amd_sched_fence_ops_finished,
-                   &fence->lock, entity->fence_context + 1, seq);
+                       &fence->lock, entity->fence_context + 1, seq);
        return fence;
 }
 void amd_sched_fence_scheduled(struct amd_sched_fence *fence)
 {
-        int ret = fence_signal(&fence->scheduled);
+        int ret = dma_fence_signal(&fence->scheduled);
        if (!ret)
-                FENCE_TRACE(&fence->scheduled, "signaled from irq context\n");
+                DMA_FENCE_TRACE(&fence->scheduled,
+                                "signaled from irq context\n");
        else
-                FENCE_TRACE(&fence->scheduled, "was already signaled\n");
+                DMA_FENCE_TRACE(&fence->scheduled,
+                                "was already signaled\n");
 }
 void amd_sched_fence_finished(struct amd_sched_fence *fence)
 {
-        int ret = fence_signal(&fence->finished);
+        int ret = dma_fence_signal(&fence->finished);
        if (!ret)
-                FENCE_TRACE(&fence->finished, "signaled from irq context\n");
+                DMA_FENCE_TRACE(&fence->finished,
+                                "signaled from irq context\n");
        else
-                FENCE_TRACE(&fence->finished, "was already signaled\n");
+                DMA_FENCE_TRACE(&fence->finished,
+                                "was already signaled\n");
 }
-static const char *amd_sched_fence_get_driver_name(struct fence *fence)
+static const char *amd_sched_fence_get_driver_name(struct dma_fence *fence)
 {
        return "amd_sched";
 }
-static const char *amd_sched_fence_get_timeline_name(struct fence *f)
+static const char *amd_sched_fence_get_timeline_name(struct dma_fence *f)
 {
        struct amd_sched_fence *fence = to_amd_sched_fence(f);
        return (const char *)fence->sched->name;
 }
-static bool amd_sched_fence_enable_signaling(struct fence *f)
+static bool amd_sched_fence_enable_signaling(struct dma_fence *f)
 {
        return true;
 }
@@ -95,10 +99,10 @@ static bool amd_sched_fence_enable_signaling(struct fence *f)
 */
 static void amd_sched_fence_free(struct rcu_head *rcu)
 {
-        struct fence *f = container_of(rcu, struct fence, rcu);
+        struct dma_fence *f = container_of(rcu, struct dma_fence, rcu);
        struct amd_sched_fence *fence = to_amd_sched_fence(f);
-        fence_put(fence->parent);
+        dma_fence_put(fence->parent);
        kmem_cache_free(sched_fence_slab, fence);
 }
@@ -110,7 +114,7 @@ static void amd_sched_fence_free(struct rcu_head *rcu)
 * This function is called when the reference count becomes zero.
 * It just RCU schedules freeing up the fence.
 */
-static void amd_sched_fence_release_scheduled(struct fence *f)
+static void amd_sched_fence_release_scheduled(struct dma_fence *f)
 {
        struct amd_sched_fence *fence = to_amd_sched_fence(f);
@@ -124,27 +128,27 @@ static void amd_sched_fence_release_scheduled(struct fence *f)
 *
 * Drop the extra reference from the scheduled fence to the base fence.
 */
-static void amd_sched_fence_release_finished(struct fence *f)
+static void amd_sched_fence_release_finished(struct dma_fence *f)
 {
        struct amd_sched_fence *fence = to_amd_sched_fence(f);
-        fence_put(&fence->scheduled);
+        dma_fence_put(&fence->scheduled);
 }
-const struct fence_ops amd_sched_fence_ops_scheduled = {
+const struct dma_fence_ops amd_sched_fence_ops_scheduled = {
        .get_driver_name = amd_sched_fence_get_driver_name,
        .get_timeline_name = amd_sched_fence_get_timeline_name,
        .enable_signaling = amd_sched_fence_enable_signaling,
        .signaled = NULL,
-        .wait = fence_default_wait,
+        .wait = dma_fence_default_wait,
        .release = amd_sched_fence_release_scheduled,
 };
-const struct fence_ops amd_sched_fence_ops_finished = {
+const struct dma_fence_ops amd_sched_fence_ops_finished = {
        .get_driver_name = amd_sched_fence_get_driver_name,
        .get_timeline_name = amd_sched_fence_get_timeline_name,
        .enable_signaling = amd_sched_fence_enable_signaling,
        .signaled = NULL,
-        .wait = fence_default_wait,
+        .wait = dma_fence_default_wait,
        .release = amd_sched_fence_release_finished,
 };
diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c
index 1b5a32df9a9a..c32fb3c1d6f0 100644
--- a/drivers/gpu/drm/drm_atomic.c
+++ b/drivers/gpu/drm/drm_atomic.c
@@ -1463,7 +1463,7 @@ EXPORT_SYMBOL(drm_atomic_nonblocking_commit);
 static struct drm_pending_vblank_event *create_vblank_event(
                struct drm_device *dev, struct drm_file *file_priv,
-                struct fence *fence, uint64_t user_data)
+                struct dma_fence *fence, uint64_t user_data)
 {
        struct drm_pending_vblank_event *e = NULL;
        int ret;
diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
index f9362760bfb2..75ad01d595fd 100644
--- a/drivers/gpu/drm/drm_atomic_helper.c
+++ b/drivers/gpu/drm/drm_atomic_helper.c
@@ -30,7 +30,7 @@
 #include <drm/drm_plane_helper.h>
 #include <drm/drm_crtc_helper.h>
 #include <drm/drm_atomic_helper.h>
-#include <linux/fence.h>
+#include <linux/dma-fence.h>
 #include "drm_crtc_internal.h"
@@ -1017,7 +1017,7 @@ EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_enables);
 * drm_atomic_helper_swap_state() so it uses the current plane state (and
 * just uses the atomic state to find the changed planes)
 *
- * Returns zero if success or < 0 if fence_wait() fails.
+ * Returns zero if success or < 0 if dma_fence_wait() fails.
 */
 int drm_atomic_helper_wait_for_fences(struct drm_device *dev,
                                      struct drm_atomic_state *state,
@@ -1041,11 +1041,11 @@ int drm_atomic_helper_wait_for_fences(struct drm_device *dev,
                 * still interrupt the operation. Instead of blocking until the
                 * timer expires, make the wait interruptible.
                 */
-                ret = fence_wait(plane_state->fence, pre_swap);
+                ret = dma_fence_wait(plane_state->fence, pre_swap);
                if (ret)
                        return ret;
-                fence_put(plane_state->fence);
+                dma_fence_put(plane_state->fence);
                plane_state->fence = NULL;
        }
diff --git a/drivers/gpu/drm/drm_fops.c b/drivers/gpu/drm/drm_fops.c
index 8bed5f459182..cf993dbf602e 100644
--- a/drivers/gpu/drm/drm_fops.c
+++ b/drivers/gpu/drm/drm_fops.c
@@ -665,7 +665,7 @@ void drm_event_cancel_free(struct drm_device *dev,
        spin_unlock_irqrestore(&dev->event_lock, flags);
        if (p->fence)
-                fence_put(p->fence);
+                dma_fence_put(p->fence);
        kfree(p);
 }
@@ -696,8 +696,8 @@ void drm_send_event_locked(struct drm_device *dev, struct drm_pending_event *e)
        }
        if (e->fence) {
-                fence_signal(e->fence);
+                dma_fence_signal(e->fence);
-                fence_put(e->fence);
+                dma_fence_put(e->fence);
        }
        if (!e->file_priv) {
diff --git a/drivers/gpu/drm/etnaviv/etnaviv_gem.c b/drivers/gpu/drm/etnaviv/etnaviv_gem.c
index 3755ef935af4..7d066a91d778 100644
--- a/drivers/gpu/drm/etnaviv/etnaviv_gem.c
+++ b/drivers/gpu/drm/etnaviv/etnaviv_gem.c
@@ -466,10 +466,10 @@ int etnaviv_gem_wait_bo(struct etnaviv_gpu *gpu, struct drm_gem_object *obj,
 }
 #ifdef CONFIG_DEBUG_FS
-static void etnaviv_gem_describe_fence(struct fence *fence,
+static void etnaviv_gem_describe_fence(struct dma_fence *fence,
        const char *type, struct seq_file *m)
 {
-        if (!test_bit(FENCE_FLAG_SIGNALED_BIT, &fence->flags))
+        if (!test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags))
                seq_printf(m, "\t%9s: %s %s seq %u\n",
                           type,
                           fence->ops->get_driver_name(fence),
@@ -482,7 +482,7 @@ static void etnaviv_gem_describe(struct drm_gem_object *obj, struct seq_file *m)
        struct etnaviv_gem_object *etnaviv_obj = to_etnaviv_bo(obj);
        struct reservation_object *robj = etnaviv_obj->resv;
        struct reservation_object_list *fobj;
-        struct fence *fence;
+        struct dma_fence *fence;
        unsigned long off = drm_vma_node_start(&obj->vma_node);
        seq_printf(m, "%08x: %c %2d (%2d) %08lx %p %zd\n",
diff --git a/drivers/gpu/drm/etnaviv/etnaviv_gpu.c b/drivers/gpu/drm/etnaviv/etnaviv_gpu.c
index b1254f885fed..d2211825e5c8 100644
--- a/drivers/gpu/drm/etnaviv/etnaviv_gpu.c
+++ b/drivers/gpu/drm/etnaviv/etnaviv_gpu.c
@@ -15,7 +15,7 @@
 */
 #include <linux/component.h>
-#include <linux/fence.h>
+#include <linux/dma-fence.h>
 #include <linux/moduleparam.h>
 #include <linux/of_device.h>
 #include "etnaviv_dump.h"
@@ -882,7 +882,7 @@ static void recover_worker(struct work_struct *work)
        for (i = 0; i < ARRAY_SIZE(gpu->event); i++) {
                if (!gpu->event[i].used)
                        continue;
-                fence_signal(gpu->event[i].fence);
+                dma_fence_signal(gpu->event[i].fence);
                gpu->event[i].fence = NULL;
                gpu->event[i].used = false;
                complete(&gpu->event_free);
@@ -952,55 +952,55 @@ static void hangcheck_disable(struct etnaviv_gpu *gpu)
 /* fence object management */
 struct etnaviv_fence {
        struct etnaviv_gpu *gpu;
-        struct fence base;
+        struct dma_fence base;
 };
-static inline struct etnaviv_fence *to_etnaviv_fence(struct fence *fence)
+static inline struct etnaviv_fence *to_etnaviv_fence(struct dma_fence *fence)
 {
        return container_of(fence, struct etnaviv_fence, base);
 }
-static const char *etnaviv_fence_get_driver_name(struct fence *fence)
+static const char *etnaviv_fence_get_driver_name(struct dma_fence *fence)
 {
        return "etnaviv";
 }
-static const char *etnaviv_fence_get_timeline_name(struct fence *fence)
+static const char *etnaviv_fence_get_timeline_name(struct dma_fence *fence)
 {
        struct etnaviv_fence *f = to_etnaviv_fence(fence);
        return dev_name(f->gpu->dev);
 }
-static bool etnaviv_fence_enable_signaling(struct fence *fence)
+static bool etnaviv_fence_enable_signaling(struct dma_fence *fence)
 {
        return true;
 }
-static bool etnaviv_fence_signaled(struct fence *fence)
+static bool etnaviv_fence_signaled(struct dma_fence *fence)
 {
        struct etnaviv_fence *f = to_etnaviv_fence(fence);
        return fence_completed(f->gpu, f->base.seqno);
 }
-static void etnaviv_fence_release(struct fence *fence)
+static void etnaviv_fence_release(struct dma_fence *fence)
 {
        struct etnaviv_fence *f = to_etnaviv_fence(fence);
        kfree_rcu(f, base.rcu);
 }
-static const struct fence_ops etnaviv_fence_ops = {
+static const struct dma_fence_ops etnaviv_fence_ops = {
        .get_driver_name = etnaviv_fence_get_driver_name,
        .get_timeline_name = etnaviv_fence_get_timeline_name,
        .enable_signaling = etnaviv_fence_enable_signaling,
        .signaled = etnaviv_fence_signaled,
-        .wait = fence_default_wait,
+        .wait = dma_fence_default_wait,
        .release = etnaviv_fence_release,
 };
-static struct fence *etnaviv_gpu_fence_alloc(struct etnaviv_gpu *gpu)
+static struct dma_fence *etnaviv_gpu_fence_alloc(struct etnaviv_gpu *gpu)
 {
        struct etnaviv_fence *f;
@@ -1010,8 +1010,8 @@ static struct fence *etnaviv_gpu_fence_alloc(struct etnaviv_gpu *gpu)
        f->gpu = gpu;
-        fence_init(&f->base, &etnaviv_fence_ops, &gpu->fence_spinlock,
+        dma_fence_init(&f->base, &etnaviv_fence_ops, &gpu->fence_spinlock,
-                   gpu->fence_context, ++gpu->next_fence);
+                       gpu->fence_context, ++gpu->next_fence);
        return &f->base;
 }
@@ -1021,7 +1021,7 @@ int etnaviv_gpu_fence_sync_obj(struct etnaviv_gem_object *etnaviv_obj,
 {
        struct reservation_object *robj = etnaviv_obj->resv;
        struct reservation_object_list *fobj;
-        struct fence *fence;
+        struct dma_fence *fence;
        int i, ret;
        if (!exclusive) {
@@ -1039,7 +1039,7 @@ int etnaviv_gpu_fence_sync_obj(struct etnaviv_gem_object *etnaviv_obj,
                /* Wait on any existing exclusive fence which isn't our own */
                fence = reservation_object_get_excl(robj);
                if (fence && fence->context != context) {
-                        ret = fence_wait(fence, true);
+                        ret = dma_fence_wait(fence, true);
                        if (ret)
                                return ret;
                }
@@ -1052,7 +1052,7 @@ int etnaviv_gpu_fence_sync_obj(struct etnaviv_gem_object *etnaviv_obj,
                fence = rcu_dereference_protected(fobj->shared[i],
                                                reservation_object_held(robj));
                if (fence->context != context) {
-                        ret = fence_wait(fence, true);
+                        ret = dma_fence_wait(fence, true);
                        if (ret)
                                return ret;
                }
@@ -1158,11 +1158,11 @@ static void retire_worker(struct work_struct *work)
        mutex_lock(&gpu->lock);
        list_for_each_entry_safe(cmdbuf, tmp, &gpu->active_cmd_list, node) {
-                if (!fence_is_signaled(cmdbuf->fence))
+                if (!dma_fence_is_signaled(cmdbuf->fence))
                        break;
                list_del(&cmdbuf->node);
-                fence_put(cmdbuf->fence);
+                dma_fence_put(cmdbuf->fence);
                for (i = 0; i < cmdbuf->nr_bos; i++) {
                        struct etnaviv_vram_mapping *mapping = cmdbuf->bo_map[i];
@@ -1275,7 +1275,7 @@ void etnaviv_gpu_pm_put(struct etnaviv_gpu *gpu)
 int etnaviv_gpu_submit(struct etnaviv_gpu *gpu,
        struct etnaviv_gem_submit *submit, struct etnaviv_cmdbuf *cmdbuf)
 {
-        struct fence *fence;
+        struct dma_fence *fence;
        unsigned int event, i;
        int ret;
@@ -1391,7 +1391,7 @@ static irqreturn_t irq_handler(int irq, void *data)
                }
                while ((event = ffs(intr)) != 0) {
-                        struct fence *fence;
+                        struct dma_fence *fence;
                        event -= 1;
@@ -1401,7 +1401,7 @@ static irqreturn_t irq_handler(int irq, void *data)
                        fence = gpu->event[event].fence;
                        gpu->event[event].fence = NULL;
-                        fence_signal(fence);
+                        dma_fence_signal(fence);
                        /*
                         * Events can be processed out of order.  Eg,
@@ -1553,7 +1553,7 @@ static int etnaviv_gpu_bind(struct device *dev, struct device *master,
                return ret;
        gpu->drm = drm;
-        gpu->fence_context = fence_context_alloc(1);
+        gpu->fence_context = dma_fence_context_alloc(1);
        spin_lock_init(&gpu->fence_spinlock);
        INIT_LIST_HEAD(&gpu->active_cmd_list);
diff --git a/drivers/gpu/drm/etnaviv/etnaviv_gpu.h b/drivers/gpu/drm/etnaviv/etnaviv_gpu.h
index 73c278dc3706..8c6b824e9d0a 100644
--- a/drivers/gpu/drm/etnaviv/etnaviv_gpu.h
+++ b/drivers/gpu/drm/etnaviv/etnaviv_gpu.h
@@ -89,7 +89,7 @@ struct etnaviv_chip_identity {
 struct etnaviv_event {
        bool used;
-        struct fence *fence;
+        struct dma_fence *fence;
 };
 struct etnaviv_cmdbuf;
@@ -163,7 +163,7 @@ struct etnaviv_cmdbuf {
        /* vram node used if the cmdbuf is mapped through the MMUv2 */
        struct drm_mm_node vram_node;
        /* fence after which this buffer is to be disposed */
-        struct fence *fence;
+        struct dma_fence *fence;
        /* target exec state */
        u32 exec_state;
        /* per GPU in-flight list */
diff --git a/drivers/gpu/drm/i915/i915_gem_request.c b/drivers/gpu/drm/i915/i915_gem_request.c
index 74ede1f53372..f9af2a00625e 100644
--- a/drivers/gpu/drm/i915/i915_gem_request.c
+++ b/drivers/gpu/drm/i915/i915_gem_request.c
@@ -26,12 +26,12 @@
 #include "i915_drv.h"
-static const char *i915_fence_get_driver_name(struct fence *fence)
+static const char *i915_fence_get_driver_name(struct dma_fence *fence)
 {
        return "i915";
 }
-static const char *i915_fence_get_timeline_name(struct fence *fence)
+static const char *i915_fence_get_timeline_name(struct dma_fence *fence)
 {
        /* Timelines are bound by eviction to a VM. However, since
         * we only have a global seqno at the moment, we only have
@@ -42,12 +42,12 @@ static const char *i915_fence_get_timeline_name(struct fence *fence)
        return "global";
 }
-static bool i915_fence_signaled(struct fence *fence)
+static bool i915_fence_signaled(struct dma_fence *fence)
 {
        return i915_gem_request_completed(to_request(fence));
 }
-static bool i915_fence_enable_signaling(struct fence *fence)
+static bool i915_fence_enable_signaling(struct dma_fence *fence)
 {
        if (i915_fence_signaled(fence))
                return false;
@@ -56,7 +56,7 @@ static bool i915_fence_enable_signaling(struct fence *fence)
        return true;
 }
-static signed long i915_fence_wait(struct fence *fence,
+static signed long i915_fence_wait(struct dma_fence *fence,
                                   bool interruptible,
                                   signed long timeout_jiffies)
 {
@@ -85,26 +85,26 @@ static signed long i915_fence_wait(struct fence *fence,
        return timeout_jiffies;
 }
-static void i915_fence_value_str(struct fence *fence, char *str, int size)
+static void i915_fence_value_str(struct dma_fence *fence, char *str, int size)
 {
        snprintf(str, size, "%u", fence->seqno);
 }
-static void i915_fence_timeline_value_str(struct fence *fence, char *str,
+static void i915_fence_timeline_value_str(struct dma_fence *fence, char *str,
                                          int size)
 {
        snprintf(str, size, "%u",
                 intel_engine_get_seqno(to_request(fence)->engine));
 }
-static void i915_fence_release(struct fence *fence)
+static void i915_fence_release(struct dma_fence *fence)
 {
        struct drm_i915_gem_request *req = to_request(fence);
        kmem_cache_free(req->i915->requests, req);
 }
-const struct fence_ops i915_fence_ops = {
+const struct dma_fence_ops i915_fence_ops = {
        .get_driver_name = i915_fence_get_driver_name,
        .get_timeline_name = i915_fence_get_timeline_name,
        .enable_signaling = i915_fence_enable_signaling,
@@ -388,8 +388,8 @@ i915_gem_request_alloc(struct intel_engine_cs *engine,
         * The reference count is incremented atomically. If it is zero,
         * the lookup knows the request is unallocated and complete. Otherwise,
         * it is either still in use, or has been reallocated and reset
-         * with fence_init(). This increment is safe for release as we check
+         * with dma_fence_init(). This increment is safe for release as we
-         * that the request we have a reference to and matches the active
+         * check that the request we have a reference to and matches the active
         * request.
         *
         * Before we increment the refcount, we chase the request->engine
@@ -412,11 +412,11 @@ i915_gem_request_alloc(struct intel_engine_cs *engine,
                goto err;
        spin_lock_init(&req->lock);
-        fence_init(&req->fence,
+        dma_fence_init(&req->fence,
-                   &i915_fence_ops,
+                       &i915_fence_ops,
-                   &req->lock,
+                       &req->lock,
-                   engine->fence_context,
+                       engine->fence_context,
-                   seqno);
+                       seqno);
        i915_sw_fence_init(&req->submit, submit_notify);
diff --git a/drivers/gpu/drm/i915/i915_gem_request.h b/drivers/gpu/drm/i915/i915_gem_request.h
index 974bd7bcc801..bceeaa3a5193 100644
--- a/drivers/gpu/drm/i915/i915_gem_request.h
+++ b/drivers/gpu/drm/i915/i915_gem_request.h
@@ -25,7 +25,7 @@
 #ifndef I915_GEM_REQUEST_H
 #define I915_GEM_REQUEST_H
-#include <linux/fence.h>
+#include <linux/dma-fence.h>
 #include "i915_gem.h"
 #include "i915_sw_fence.h"
@@ -62,7 +62,7 @@ struct intel_signal_node {
 * The requests are reference counted.
 */
 struct drm_i915_gem_request {
-        struct fence fence;
+        struct dma_fence fence;
        spinlock_t lock;
        /** On Which ring this request was generated */
@@ -145,9 +145,9 @@ struct drm_i915_gem_request {
        struct list_head execlist_link;
 };
-extern const struct fence_ops i915_fence_ops;
+extern const struct dma_fence_ops i915_fence_ops;
-static inline bool fence_is_i915(struct fence *fence)
+static inline bool fence_is_i915(struct dma_fence *fence)
 {
        return fence->ops == &i915_fence_ops;
 }
@@ -172,7 +172,7 @@ i915_gem_request_get_engine(struct drm_i915_gem_request *req)
 }
 static inline struct drm_i915_gem_request *
-to_request(struct fence *fence)
+to_request(struct dma_fence *fence)
 {
        /* We assume that NULL fence/request are interoperable */
        BUILD_BUG_ON(offsetof(struct drm_i915_gem_request, fence) != 0);
@@ -183,19 +183,19 @@ to_request(struct fence *fence)
 static inline struct drm_i915_gem_request *
 i915_gem_request_get(struct drm_i915_gem_request *req)
 {
-        return to_request(fence_get(&req->fence));
+        return to_request(dma_fence_get(&req->fence));
 }
 static inline struct drm_i915_gem_request *
 i915_gem_request_get_rcu(struct drm_i915_gem_request *req)
 {
-        return to_request(fence_get_rcu(&req->fence));
+        return to_request(dma_fence_get_rcu(&req->fence));
 }
 static inline void
 i915_gem_request_put(struct drm_i915_gem_request *req)
 {
-        fence_put(&req->fence);
+        dma_fence_put(&req->fence);
 }
 static inline void i915_gem_request_assign(struct drm_i915_gem_request **pdst,
@@ -497,7 +497,7 @@ __i915_gem_active_get_rcu(const struct i915_gem_active *active)
                 * compiler.
                 *
                 * The atomic operation at the heart of
-                 * i915_gem_request_get_rcu(), see fence_get_rcu(), is
+                 * i915_gem_request_get_rcu(), see dma_fence_get_rcu(), is
                 * atomic_inc_not_zero() which is only a full memory barrier
                 * when successful. That is, if i915_gem_request_get_rcu()
                 * returns the request (and so with the reference counted
diff --git a/drivers/gpu/drm/i915/i915_sw_fence.c b/drivers/gpu/drm/i915/i915_sw_fence.c
index 1e5cbc585ca2..8185002d7ec8 100644
--- a/drivers/gpu/drm/i915/i915_sw_fence.c
+++ b/drivers/gpu/drm/i915/i915_sw_fence.c
@@ -8,7 +8,7 @@
 */
 #include <linux/slab.h>
-#include <linux/fence.h>
+#include <linux/dma-fence.h>
 #include <linux/reservation.h>
 #include "i915_sw_fence.h"
@@ -226,49 +226,50 @@ int i915_sw_fence_await_sw_fence(struct i915_sw_fence *fence,
        return pending;
 }
-struct dma_fence_cb {
+struct i915_sw_dma_fence_cb {
-        struct fence_cb base;
+        struct dma_fence_cb base;
        struct i915_sw_fence *fence;
-        struct fence *dma;
+        struct dma_fence *dma;
        struct timer_list timer;
 };
 static void timer_i915_sw_fence_wake(unsigned long data)
 {
-        struct dma_fence_cb *cb = (struct dma_fence_cb *)data;
+        struct i915_sw_dma_fence_cb *cb = (struct i915_sw_dma_fence_cb *)data;
        printk(KERN_WARNING "asynchronous wait on fence %s:%s:%x timed out\n",
               cb->dma->ops->get_driver_name(cb->dma),
               cb->dma->ops->get_timeline_name(cb->dma),
               cb->dma->seqno);
-        fence_put(cb->dma);
+        dma_fence_put(cb->dma);
        cb->dma = NULL;
        i915_sw_fence_commit(cb->fence);
        cb->timer.function = NULL;
 }
-static void dma_i915_sw_fence_wake(struct fence *dma, struct fence_cb *data)
+static void dma_i915_sw_fence_wake(struct dma_fence *dma,
+                                   struct dma_fence_cb *data)
 {
-        struct dma_fence_cb *cb = container_of(data, typeof(*cb), base);
+        struct i915_sw_dma_fence_cb *cb = container_of(data, typeof(*cb), base);
        del_timer_sync(&cb->timer);
        if (cb->timer.function)
                i915_sw_fence_commit(cb->fence);
-        fence_put(cb->dma);
+        dma_fence_put(cb->dma);
        kfree(cb);
 }
 int i915_sw_fence_await_dma_fence(struct i915_sw_fence *fence,
-                                  struct fence *dma,
+                                  struct dma_fence *dma,
                                  unsigned long timeout,
                                  gfp_t gfp)
 {
-        struct dma_fence_cb *cb;
+        struct i915_sw_dma_fence_cb *cb;
        int ret;
-        if (fence_is_signaled(dma))
+        if (dma_fence_is_signaled(dma))
                return 0;
        cb = kmalloc(sizeof(*cb), gfp);
@@ -276,7 +277,7 @@ int i915_sw_fence_await_dma_fence(struct i915_sw_fence *fence,
                if (!gfpflags_allow_blocking(gfp))
                        return -ENOMEM;
-                return fence_wait(dma, false);
+                return dma_fence_wait(dma, false);
        }
        cb->fence = i915_sw_fence_get(fence);
@@ -287,11 +288,11 @@ int i915_sw_fence_await_dma_fence(struct i915_sw_fence *fence,
                      timer_i915_sw_fence_wake, (unsigned long)cb,
                      TIMER_IRQSAFE);
        if (timeout) {
-                cb->dma = fence_get(dma);
+                cb->dma = dma_fence_get(dma);
                mod_timer(&cb->timer, round_jiffies_up(jiffies + timeout));
        }
-        ret = fence_add_callback(dma, &cb->base, dma_i915_sw_fence_wake);
+        ret = dma_fence_add_callback(dma, &cb->base, dma_i915_sw_fence_wake);
        if (ret == 0) {
                ret = 1;
        } else {
@@ -305,16 +306,16 @@ int i915_sw_fence_await_dma_fence(struct i915_sw_fence *fence,
 int i915_sw_fence_await_reservation(struct i915_sw_fence *fence,
                                    struct reservation_object *resv,
-                                    const struct fence_ops *exclude,
+                                    const struct dma_fence_ops *exclude,
                                    bool write,
                                    unsigned long timeout,
                                    gfp_t gfp)
 {
-        struct fence *excl;
+        struct dma_fence *excl;
        int ret = 0, pending;
        if (write) {
-                struct fence **shared;
+                struct dma_fence **shared;
                unsigned int count, i;
                ret = reservation_object_get_fences_rcu(resv,
@@ -339,7 +340,7 @@ int i915_sw_fence_await_reservation(struct i915_sw_fence *fence,
                }
                for (i = 0; i < count; i++)
-                        fence_put(shared[i]);
+                        dma_fence_put(shared[i]);
                kfree(shared);
        } else {
                excl = reservation_object_get_excl_rcu(resv);
@@ -356,7 +357,7 @@ int i915_sw_fence_await_reservation(struct i915_sw_fence *fence,
                        ret |= pending;
        }
-        fence_put(excl);
+        dma_fence_put(excl);
        return ret;
 }
diff --git a/drivers/gpu/drm/i915/i915_sw_fence.h b/drivers/gpu/drm/i915/i915_sw_fence.h
index 373141602ca4..cd239e92f67f 100644
--- a/drivers/gpu/drm/i915/i915_sw_fence.h
+++ b/drivers/gpu/drm/i915/i915_sw_fence.h
@@ -16,8 +16,8 @@
 #include <linux/wait.h>
 struct completion;
-struct fence;
+struct dma_fence;
-struct fence_ops;
+struct dma_fence_ops;
 struct reservation_object;
 struct i915_sw_fence {
@@ -47,12 +47,12 @@ int i915_sw_fence_await_sw_fence(struct i915_sw_fence *fence,
                                 struct i915_sw_fence *after,
                                 wait_queue_t *wq);
 int i915_sw_fence_await_dma_fence(struct i915_sw_fence *fence,
-                                  struct fence *dma,
+                                  struct dma_fence *dma,
                                  unsigned long timeout,
                                  gfp_t gfp);
 int i915_sw_fence_await_reservation(struct i915_sw_fence *fence,
                                    struct reservation_object *resv,
-                                    const struct fence_ops *exclude,
+                                    const struct dma_fence_ops *exclude,
                                    bool write,
                                    unsigned long timeout,
                                    gfp_t gfp);
diff --git a/drivers/gpu/drm/i915/i915_trace.h b/drivers/gpu/drm/i915/i915_trace.h
index 178798002a73..5c912c25f7d3 100644
--- a/drivers/gpu/drm/i915/i915_trace.h
+++ b/drivers/gpu/drm/i915/i915_trace.h
@@ -491,7 +491,7 @@ TRACE_EVENT(i915_gem_ring_dispatch,
                           __entry->ring = req->engine->id;
                           __entry->seqno = req->fence.seqno;
                           __entry->flags = flags;
-                           fence_enable_sw_signaling(&req->fence);
+                           dma_fence_enable_sw_signaling(&req->fence);
                           ),
            TP_printk("dev=%u, ring=%u, seqno=%u, flags=%x",
diff --git a/drivers/gpu/drm/i915/intel_breadcrumbs.c b/drivers/gpu/drm/i915/intel_breadcrumbs.c
index 23fc1042fed4..56efcc507ea2 100644
--- a/drivers/gpu/drm/i915/intel_breadcrumbs.c
+++ b/drivers/gpu/drm/i915/intel_breadcrumbs.c
@@ -464,7 +464,7 @@ static int intel_breadcrumbs_signaler(void *arg)
                                                 &request->signaling.wait);
                        local_bh_disable();
-                        fence_signal(&request->fence);
+                        dma_fence_signal(&request->fence);
                        local_bh_enable(); /* kick start the tasklets */
                        /* Find the next oldest signal. Note that as we have
@@ -502,7 +502,7 @@ void intel_engine_enable_signaling(struct drm_i915_gem_request *request)
        struct rb_node *parent, **p;
        bool first, wakeup;
-        /* locked by fence_enable_sw_signaling() */
+        /* locked by dma_fence_enable_sw_signaling() */
        assert_spin_locked(&request->lock);
        request->signaling.wait.tsk = b->signaler;
diff --git a/drivers/gpu/drm/i915/intel_engine_cs.c b/drivers/gpu/drm/i915/intel_engine_cs.c
index 2dc94812bea5..8cceb345aa0f 100644
--- a/drivers/gpu/drm/i915/intel_engine_cs.c
+++ b/drivers/gpu/drm/i915/intel_engine_cs.c
@@ -245,7 +245,7 @@ void intel_engine_setup_common(struct intel_engine_cs *engine)
        INIT_LIST_HEAD(&engine->execlist_queue);
        spin_lock_init(&engine->execlist_lock);
-        engine->fence_context = fence_context_alloc(1);
+        engine->fence_context = dma_fence_context_alloc(1);
        intel_engine_init_requests(engine);
        intel_engine_init_hangcheck(engine);
diff --git a/drivers/gpu/drm/msm/msm_drv.h b/drivers/gpu/drm/msm/msm_drv.h
index d0da52f2a806..940bf4992fe2 100644
--- a/drivers/gpu/drm/msm/msm_drv.h
+++ b/drivers/gpu/drm/msm/msm_drv.h
@@ -217,7 +217,7 @@ void msm_gem_vunmap(struct drm_gem_object *obj);
 int msm_gem_sync_object(struct drm_gem_object *obj,
                struct msm_fence_context *fctx, bool exclusive);
 void msm_gem_move_to_active(struct drm_gem_object *obj,
-                struct msm_gpu *gpu, bool exclusive, struct fence *fence);
+                struct msm_gpu *gpu, bool exclusive, struct dma_fence *fence);
 void msm_gem_move_to_inactive(struct drm_gem_object *obj);
 int msm_gem_cpu_prep(struct drm_gem_object *obj, uint32_t op, ktime_t *timeout);
 int msm_gem_cpu_fini(struct drm_gem_object *obj);
diff --git a/drivers/gpu/drm/msm/msm_fence.c b/drivers/gpu/drm/msm/msm_fence.c
index a9b9b1c95a2e..3f299c537b77 100644
--- a/drivers/gpu/drm/msm/msm_fence.c
+++ b/drivers/gpu/drm/msm/msm_fence.c
@@ -15,7 +15,7 @@
 * this program.  If not, see <http://www.gnu.org/licenses/>.
 */
-#include <linux/fence.h>
+#include <linux/dma-fence.h>
 #include "msm_drv.h"
 #include "msm_fence.h"
@@ -32,7 +32,7 @@ msm_fence_context_alloc(struct drm_device *dev, const char *name)
        fctx->dev = dev;
        fctx->name = name;
-        fctx->context = fence_context_alloc(1);
+        fctx->context = dma_fence_context_alloc(1);
        init_waitqueue_head(&fctx->event);
        spin_lock_init(&fctx->spinlock);
@@ -100,52 +100,52 @@ void msm_update_fence(struct msm_fence_context *fctx, uint32_t fence)
 struct msm_fence {
        struct msm_fence_context *fctx;
-        struct fence base;
+        struct dma_fence base;
 };
-static inline struct msm_fence *to_msm_fence(struct fence *fence)
+static inline struct msm_fence *to_msm_fence(struct dma_fence *fence)
 {
        return container_of(fence, struct msm_fence, base);
 }
-static const char *msm_fence_get_driver_name(struct fence *fence)
+static const char *msm_fence_get_driver_name(struct dma_fence *fence)
 {
        return "msm";
 }
-static const char *msm_fence_get_timeline_name(struct fence *fence)
+static const char *msm_fence_get_timeline_name(struct dma_fence *fence)
 {
        struct msm_fence *f = to_msm_fence(fence);
        return f->fctx->name;
 }
-static bool msm_fence_enable_signaling(struct fence *fence)
+static bool msm_fence_enable_signaling(struct dma_fence *fence)
 {
        return true;
 }
-static bool msm_fence_signaled(struct fence *fence)
+static bool msm_fence_signaled(struct dma_fence *fence)
 {
        struct msm_fence *f = to_msm_fence(fence);
        return fence_completed(f->fctx, f->base.seqno);
 }
-static void msm_fence_release(struct fence *fence)
+static void msm_fence_release(struct dma_fence *fence)
 {
        struct msm_fence *f = to_msm_fence(fence);
        kfree_rcu(f, base.rcu);
 }
-static const struct fence_ops msm_fence_ops = {
+static const struct dma_fence_ops msm_fence_ops = {
        .get_driver_name = msm_fence_get_driver_name,
        .get_timeline_name = msm_fence_get_timeline_name,
        .enable_signaling = msm_fence_enable_signaling,
        .signaled = msm_fence_signaled,
-        .wait = fence_default_wait,
+        .wait = dma_fence_default_wait,
        .release = msm_fence_release,
 };
-struct fence *
+struct dma_fence *
 msm_fence_alloc(struct msm_fence_context *fctx)
 {
        struct msm_fence *f;
@@ -156,8 +156,8 @@ msm_fence_alloc(struct msm_fence_context *fctx)
        f->fctx = fctx;
-        fence_init(&f->base, &msm_fence_ops, &fctx->spinlock,
+        dma_fence_init(&f->base, &msm_fence_ops, &fctx->spinlock,
-                        fctx->context, ++fctx->last_fence);
+                       fctx->context, ++fctx->last_fence);
        return &f->base;
 }
diff --git a/drivers/gpu/drm/msm/msm_fence.h b/drivers/gpu/drm/msm/msm_fence.h
index ceb5b3d314b4..56061aa1959d 100644
--- a/drivers/gpu/drm/msm/msm_fence.h
+++ b/drivers/gpu/drm/msm/msm_fence.h
@@ -41,6 +41,6 @@ int msm_queue_fence_cb(struct msm_fence_context *fctx,
                struct msm_fence_cb *cb, uint32_t fence);
 void msm_update_fence(struct msm_fence_context *fctx, uint32_t fence);
-struct fence * msm_fence_alloc(struct msm_fence_context *fctx);
+struct dma_fence * msm_fence_alloc(struct msm_fence_context *fctx);
 #endif
diff --git a/drivers/gpu/drm/msm/msm_gem.c b/drivers/gpu/drm/msm/msm_gem.c
index b6ac27e31929..57db7dbbb618 100644
--- a/drivers/gpu/drm/msm/msm_gem.c
+++ b/drivers/gpu/drm/msm/msm_gem.c
@@ -521,7 +521,7 @@ int msm_gem_sync_object(struct drm_gem_object *obj,
 {
        struct msm_gem_object *msm_obj = to_msm_bo(obj);
        struct reservation_object_list *fobj;
-        struct fence *fence;
+        struct dma_fence *fence;
        int i, ret;
        if (!exclusive) {
@@ -540,7 +540,7 @@ int msm_gem_sync_object(struct drm_gem_object *obj,
                fence = reservation_object_get_excl(msm_obj->resv);
                /* don't need to wait on our own fences, since ring is fifo */
                if (fence && (fence->context != fctx->context)) {
-                        ret = fence_wait(fence, true);
+                        ret = dma_fence_wait(fence, true);
                        if (ret)
                                return ret;
                }
@@ -553,7 +553,7 @@ int msm_gem_sync_object(struct drm_gem_object *obj,
                fence = rcu_dereference_protected(fobj->shared[i],
                                                reservation_object_held(msm_obj->resv));
                if (fence->context != fctx->context) {
-                        ret = fence_wait(fence, true);
+                        ret = dma_fence_wait(fence, true);
                        if (ret)
                                return ret;
                }
@@ -563,7 +563,7 @@ int msm_gem_sync_object(struct drm_gem_object *obj,
 }
 void msm_gem_move_to_active(struct drm_gem_object *obj,
-                struct msm_gpu *gpu, bool exclusive, struct fence *fence)
+                struct msm_gpu *gpu, bool exclusive, struct dma_fence *fence)
 {
        struct msm_gem_object *msm_obj = to_msm_bo(obj);
        WARN_ON(msm_obj->madv != MSM_MADV_WILLNEED);
@@ -616,10 +616,10 @@ int msm_gem_cpu_fini(struct drm_gem_object *obj)
 }
 #ifdef CONFIG_DEBUG_FS
-static void describe_fence(struct fence *fence, const char *type,
+static void describe_fence(struct dma_fence *fence, const char *type,
                struct seq_file *m)
 {
-        if (!fence_is_signaled(fence))
+        if (!dma_fence_is_signaled(fence))
                seq_printf(m, "\t%9s: %s %s seq %u\n", type,
                                fence->ops->get_driver_name(fence),
                                fence->ops->get_timeline_name(fence),
@@ -631,7 +631,7 @@ void msm_gem_describe(struct drm_gem_object *obj, struct seq_file *m)
        struct msm_gem_object *msm_obj = to_msm_bo(obj);
        struct reservation_object *robj = msm_obj->resv;
        struct reservation_object_list *fobj;
-        struct fence *fence;
+        struct dma_fence *fence;
        uint64_t off = drm_vma_node_start(&obj->vma_node);
        const char *madv;
diff --git a/drivers/gpu/drm/msm/msm_gem.h b/drivers/gpu/drm/msm/msm_gem.h
index b2f13cfe945e..2cb8551fda70 100644
--- a/drivers/gpu/drm/msm/msm_gem.h
+++ b/drivers/gpu/drm/msm/msm_gem.h
@@ -104,7 +104,7 @@ struct msm_gem_submit {
        struct list_head node;   /* node in gpu submit_list */
        struct list_head bo_list;
        struct ww_acquire_ctx ticket;
-        struct fence *fence;
+        struct dma_fence *fence;
        struct pid *pid;    /* submitting process */
        bool valid;         /* true if no cmdstream patching needed */
        unsigned int nr_cmds;
diff --git a/drivers/gpu/drm/msm/msm_gem_submit.c b/drivers/gpu/drm/msm/msm_gem_submit.c
index b6a0f37a65f3..25e8786fa4ca 100644
--- a/drivers/gpu/drm/msm/msm_gem_submit.c
+++ b/drivers/gpu/drm/msm/msm_gem_submit.c
@@ -60,7 +60,7 @@ static struct msm_gem_submit *submit_create(struct drm_device *dev,
 void msm_gem_submit_free(struct msm_gem_submit *submit)
 {
-        fence_put(submit->fence);
+        dma_fence_put(submit->fence);
        list_del(&submit->node);
        put_pid(submit->pid);
        kfree(submit);
@@ -380,7 +380,7 @@ int msm_ioctl_gem_submit(struct drm_device *dev, void *data,
        struct msm_file_private *ctx = file->driver_priv;
        struct msm_gem_submit *submit;
        struct msm_gpu *gpu = priv->gpu;
-        struct fence *in_fence = NULL;
+        struct dma_fence *in_fence = NULL;
        struct sync_file *sync_file = NULL;
        int out_fence_fd = -1;
        unsigned i;
@@ -439,7 +439,7 @@ int msm_ioctl_gem_submit(struct drm_device *dev, void *data,
                 */
                if (in_fence->context != gpu->fctx->context) {
-                        ret = fence_wait(in_fence, true);
+                        ret = dma_fence_wait(in_fence, true);
                        if (ret)
                                goto out;
                }
@@ -542,7 +542,7 @@ int msm_ioctl_gem_submit(struct drm_device *dev, void *data,
 out:
        if (in_fence)
-                fence_put(in_fence);
+                dma_fence_put(in_fence);
        submit_cleanup(submit);
        if (ret)
                msm_gem_submit_free(submit);
diff --git a/drivers/gpu/drm/msm/msm_gpu.c b/drivers/gpu/drm/msm/msm_gpu.c
index 5bb09838b5ae..3249707e6834 100644
--- a/drivers/gpu/drm/msm/msm_gpu.c
+++ b/drivers/gpu/drm/msm/msm_gpu.c
@@ -476,7 +476,7 @@ static void retire_submits(struct msm_gpu *gpu)
                submit = list_first_entry(&gpu->submit_list,
                                struct msm_gem_submit, node);
-                if (fence_is_signaled(submit->fence)) {
+                if (dma_fence_is_signaled(submit->fence)) {
                        retire_submit(gpu, submit);
                } else {
                        break;
diff --git a/drivers/gpu/drm/nouveau/nouveau_bo.c b/drivers/gpu/drm/nouveau/nouveau_bo.c
index 343b8659472c..ec8ac756aab4 100644
--- a/drivers/gpu/drm/nouveau/nouveau_bo.c
+++ b/drivers/gpu/drm/nouveau/nouveau_bo.c
@@ -83,13 +83,13 @@ nv10_bo_get_tile_region(struct drm_device *dev, int i)
 static void
 nv10_bo_put_tile_region(struct drm_device *dev, struct nouveau_drm_tile *tile,
-                        struct fence *fence)
+                        struct dma_fence *fence)
 {
        struct nouveau_drm *drm = nouveau_drm(dev);
        if (tile) {
                spin_lock(&drm->tile.lock);
-                tile->fence = (struct nouveau_fence *)fence_get(fence);
+                tile->fence = (struct nouveau_fence *)dma_fence_get(fence);
                tile->used = false;
                spin_unlock(&drm->tile.lock);
        }
@@ -1243,7 +1243,7 @@ nouveau_bo_vm_cleanup(struct ttm_buffer_object *bo,
 {
        struct nouveau_drm *drm = nouveau_bdev(bo->bdev);
        struct drm_device *dev = drm->dev;
-        struct fence *fence = reservation_object_get_excl(bo->resv);
+        struct dma_fence *fence = reservation_object_get_excl(bo->resv);
        nv10_bo_put_tile_region(dev, *old_tile, fence);
        *old_tile = new_tile;
diff --git a/drivers/gpu/drm/nouveau/nouveau_fence.c b/drivers/gpu/drm/nouveau/nouveau_fence.c
index 4bb9ab892ae1..e9529ee6bc23 100644
--- a/drivers/gpu/drm/nouveau/nouveau_fence.c
+++ b/drivers/gpu/drm/nouveau/nouveau_fence.c
@@ -28,7 +28,7 @@
 #include <linux/ktime.h>
 #include <linux/hrtimer.h>
-#include <trace/events/fence.h>
+#include <trace/events/dma_fence.h>
 #include <nvif/cl826e.h>
 #include <nvif/notify.h>
@@ -38,11 +38,11 @@
 #include "nouveau_dma.h"
 #include "nouveau_fence.h"
-static const struct fence_ops nouveau_fence_ops_uevent;
+static const struct dma_fence_ops nouveau_fence_ops_uevent;
-static const struct fence_ops nouveau_fence_ops_legacy;
+static const struct dma_fence_ops nouveau_fence_ops_legacy;
 static inline struct nouveau_fence *
-from_fence(struct fence *fence)
+from_fence(struct dma_fence *fence)
 {
        return container_of(fence, struct nouveau_fence, base);
 }
@@ -58,23 +58,23 @@ nouveau_fence_signal(struct nouveau_fence *fence)
 {
        int drop = 0;
-        fence_signal_locked(&fence->base);
+        dma_fence_signal_locked(&fence->base);
        list_del(&fence->head);
        rcu_assign_pointer(fence->channel, NULL);
-        if (test_bit(FENCE_FLAG_USER_BITS, &fence->base.flags)) {
+        if (test_bit(DMA_FENCE_FLAG_USER_BITS, &fence->base.flags)) {
                struct nouveau_fence_chan *fctx = nouveau_fctx(fence);
                if (!--fctx->notify_ref)
                        drop = 1;
        }
-        fence_put(&fence->base);
+        dma_fence_put(&fence->base);
        return drop;
 }
 static struct nouveau_fence *
-nouveau_local_fence(struct fence *fence, struct nouveau_drm *drm) {
+nouveau_local_fence(struct dma_fence *fence, struct nouveau_drm *drm) {
        struct nouveau_fence_priv *priv = (void*)drm->fence;
        if (fence->ops != &nouveau_fence_ops_legacy &&
@@ -201,7 +201,7 @@ nouveau_fence_context_new(struct nouveau_channel *chan, struct nouveau_fence_cha
 struct nouveau_fence_work {
        struct work_struct work;
-        struct fence_cb cb;
+        struct dma_fence_cb cb;
        void (*func)(void *);
        void *data;
 };
@@ -214,7 +214,7 @@ nouveau_fence_work_handler(struct work_struct *kwork)
        kfree(work);
 }
-static void nouveau_fence_work_cb(struct fence *fence, struct fence_cb *cb)
+static void nouveau_fence_work_cb(struct dma_fence *fence, struct dma_fence_cb *cb)
 {
        struct nouveau_fence_work *work = container_of(cb, typeof(*work), cb);
@@ -222,12 +222,12 @@ static void nouveau_fence_work_cb(struct fence *fence, struct fence_cb *cb)
 }
 void
-nouveau_fence_work(struct fence *fence,
+nouveau_fence_work(struct dma_fence *fence,
                   void (*func)(void *), void *data)
 {
        struct nouveau_fence_work *work;
-        if (fence_is_signaled(fence))
+        if (dma_fence_is_signaled(fence))
                goto err;
        work = kmalloc(sizeof(*work), GFP_KERNEL);
@@ -245,7 +245,7 @@ nouveau_fence_work(struct fence *fence,
        work->func = func;
        work->data = data;
-        if (fence_add_callback(fence, &work->cb, nouveau_fence_work_cb) < 0)
+        if (dma_fence_add_callback(fence, &work->cb, nouveau_fence_work_cb) < 0)
                goto err_free;
        return;
@@ -266,17 +266,17 @@ nouveau_fence_emit(struct nouveau_fence *fence, struct nouveau_channel *chan)
        fence->timeout  = jiffies + (15 * HZ);
        if (priv->uevent)
-                fence_init(&fence->base, &nouveau_fence_ops_uevent,
+                dma_fence_init(&fence->base, &nouveau_fence_ops_uevent,
-                           &fctx->lock, fctx->context, ++fctx->sequence);
+                               &fctx->lock, fctx->context, ++fctx->sequence);
        else
-                fence_init(&fence->base, &nouveau_fence_ops_legacy,
+                dma_fence_init(&fence->base, &nouveau_fence_ops_legacy,
-                           &fctx->lock, fctx->context, ++fctx->sequence);
+                               &fctx->lock, fctx->context, ++fctx->sequence);
        kref_get(&fctx->fence_ref);
-        trace_fence_emit(&fence->base);
+        trace_dma_fence_emit(&fence->base);
        ret = fctx->emit(fence);
        if (!ret) {
-                fence_get(&fence->base);
+                dma_fence_get(&fence->base);
                spin_lock_irq(&fctx->lock);
                if (nouveau_fence_update(chan, fctx))
@@ -298,7 +298,7 @@ nouveau_fence_done(struct nouveau_fence *fence)
                struct nouveau_channel *chan;
                unsigned long flags;
-                if (test_bit(FENCE_FLAG_SIGNALED_BIT, &fence->base.flags))
+                if (test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->base.flags))
                        return true;
                spin_lock_irqsave(&fctx->lock, flags);
@@ -307,11 +307,11 @@ nouveau_fence_done(struct nouveau_fence *fence)
                        nvif_notify_put(&fctx->notify);
                spin_unlock_irqrestore(&fctx->lock, flags);
        }
-        return fence_is_signaled(&fence->base);
+        return dma_fence_is_signaled(&fence->base);
 }
 static long
-nouveau_fence_wait_legacy(struct fence *f, bool intr, long wait)
+nouveau_fence_wait_legacy(struct dma_fence *f, bool intr, long wait)
 {
        struct nouveau_fence *fence = from_fence(f);
        unsigned long sleep_time = NSEC_PER_MSEC / 1000;
@@ -378,7 +378,7 @@ nouveau_fence_wait(struct nouveau_fence *fence, bool lazy, bool intr)
        if (!lazy)
                return nouveau_fence_wait_busy(fence, intr);
-        ret = fence_wait_timeout(&fence->base, intr, 15 * HZ);
+        ret = dma_fence_wait_timeout(&fence->base, intr, 15 * HZ);
        if (ret < 0)
                return ret;
        else if (!ret)
@@ -391,7 +391,7 @@ int
 nouveau_fence_sync(struct nouveau_bo *nvbo, struct nouveau_channel *chan, bool exclusive, bool intr)
 {
        struct nouveau_fence_chan *fctx = chan->fence;
-        struct fence *fence;
+        struct dma_fence *fence;
        struct reservation_object *resv = nvbo->bo.resv;
        struct reservation_object_list *fobj;
        struct nouveau_fence *f;
@@ -421,7 +421,7 @@ nouveau_fence_sync(struct nouveau_bo *nvbo, struct nouveau_channel *chan, bool e
                }
                if (must_wait)
-                        ret = fence_wait(fence, intr);
+                        ret = dma_fence_wait(fence, intr);
                return ret;
        }
@@ -446,7 +446,7 @@ nouveau_fence_sync(struct nouveau_bo *nvbo, struct nouveau_channel *chan, bool e
                }
                if (must_wait)
-                        ret = fence_wait(fence, intr);
+                        ret = dma_fence_wait(fence, intr);
        }
        return ret;
@@ -456,7 +456,7 @@ void
 nouveau_fence_unref(struct nouveau_fence **pfence)
 {
        if (*pfence)
-                fence_put(&(*pfence)->base);
+                dma_fence_put(&(*pfence)->base);
        *pfence = NULL;
 }
@@ -484,12 +484,12 @@ nouveau_fence_new(struct nouveau_channel *chan, bool sysmem,
        return ret;
 }
-static const char *nouveau_fence_get_get_driver_name(struct fence *fence)
+static const char *nouveau_fence_get_get_driver_name(struct dma_fence *fence)
 {
        return "nouveau";
 }
-static const char *nouveau_fence_get_timeline_name(struct fence *f)
+static const char *nouveau_fence_get_timeline_name(struct dma_fence *f)
 {
        struct nouveau_fence *fence = from_fence(f);
        struct nouveau_fence_chan *fctx = nouveau_fctx(fence);
@@ -503,7 +503,7 @@ static const char *nouveau_fence_get_timeline_name(struct fence *f)
 * result. The drm node should still be there, so we can derive the index from
 * the fence context.
 */
-static bool nouveau_fence_is_signaled(struct fence *f)
+static bool nouveau_fence_is_signaled(struct dma_fence *f)
 {
        struct nouveau_fence *fence = from_fence(f);
        struct nouveau_fence_chan *fctx = nouveau_fctx(fence);
@@ -519,7 +519,7 @@ static bool nouveau_fence_is_signaled(struct fence *f)
        return ret;
 }
-static bool nouveau_fence_no_signaling(struct fence *f)
+static bool nouveau_fence_no_signaling(struct dma_fence *f)
 {
        struct nouveau_fence *fence = from_fence(f);
@@ -530,30 +530,30 @@ static bool nouveau_fence_no_signaling(struct fence *f)
        WARN_ON(atomic_read(&fence->base.refcount.refcount) <= 1);
        /*
-         * This needs uevents to work correctly, but fence_add_callback relies on
+         * This needs uevents to work correctly, but dma_fence_add_callback relies on
         * being able to enable signaling. It will still get signaled eventually,
         * just not right away.
         */
        if (nouveau_fence_is_signaled(f)) {
                list_del(&fence->head);
-                fence_put(&fence->base);
+                dma_fence_put(&fence->base);
                return false;
        }
        return true;
 }
-static void nouveau_fence_release(struct fence *f)
+static void nouveau_fence_release(struct dma_fence *f)
 {
        struct nouveau_fence *fence = from_fence(f);
        struct nouveau_fence_chan *fctx = nouveau_fctx(fence);
        kref_put(&fctx->fence_ref, nouveau_fence_context_put);
-        fence_free(&fence->base);
+        dma_fence_free(&fence->base);
 }
-static const struct fence_ops nouveau_fence_ops_legacy = {
+static const struct dma_fence_ops nouveau_fence_ops_legacy = {
        .get_driver_name = nouveau_fence_get_get_driver_name,
        .get_timeline_name = nouveau_fence_get_timeline_name,
        .enable_signaling = nouveau_fence_no_signaling,
@@ -562,7 +562,7 @@ static const struct fence_ops nouveau_fence_ops_legacy = {
        .release = nouveau_fence_release
 };
-static bool nouveau_fence_enable_signaling(struct fence *f)
+static bool nouveau_fence_enable_signaling(struct dma_fence *f)
 {
        struct nouveau_fence *fence = from_fence(f);
        struct nouveau_fence_chan *fctx = nouveau_fctx(fence);
@@ -573,18 +573,18 @@ static bool nouveau_fence_enable_signaling(struct fence *f)
        ret = nouveau_fence_no_signaling(f);
        if (ret)
-                set_bit(FENCE_FLAG_USER_BITS, &fence->base.flags);
+                set_bit(DMA_FENCE_FLAG_USER_BITS, &fence->base.flags);
        else if (!--fctx->notify_ref)
                nvif_notify_put(&fctx->notify);
        return ret;
 }
-static const struct fence_ops nouveau_fence_ops_uevent = {
+static const struct dma_fence_ops nouveau_fence_ops_uevent = {
        .get_driver_name = nouveau_fence_get_get_driver_name,
        .get_timeline_name = nouveau_fence_get_timeline_name,
        .enable_signaling = nouveau_fence_enable_signaling,
        .signaled = nouveau_fence_is_signaled,
-        .wait = fence_default_wait,
+        .wait = dma_fence_default_wait,
        .release = NULL
 };
diff --git a/drivers/gpu/drm/nouveau/nouveau_fence.h b/drivers/gpu/drm/nouveau/nouveau_fence.h
index 64c4ce7115ad..41f3c019e534 100644
--- a/drivers/gpu/drm/nouveau/nouveau_fence.h
+++ b/drivers/gpu/drm/nouveau/nouveau_fence.h
@@ -1,14 +1,14 @@
 #ifndef __NOUVEAU_FENCE_H__
 #define __NOUVEAU_FENCE_H__
-#include <linux/fence.h>
+#include <linux/dma-fence.h>
 #include <nvif/notify.h>
 struct nouveau_drm;
 struct nouveau_bo;
 struct nouveau_fence {
-        struct fence base;
+        struct dma_fence base;
        struct list_head head;
@@ -24,7 +24,7 @@ void nouveau_fence_unref(struct nouveau_fence **);
 int  nouveau_fence_emit(struct nouveau_fence *, struct nouveau_channel *);
 bool nouveau_fence_done(struct nouveau_fence *);
-void nouveau_fence_work(struct fence *, void (*)(void *), void *);
+void nouveau_fence_work(struct dma_fence *, void (*)(void *), void *);
 int  nouveau_fence_wait(struct nouveau_fence *, bool lazy, bool intr);
 int  nouveau_fence_sync(struct nouveau_bo *, struct nouveau_channel *, bool exclusive, bool intr);
diff --git a/drivers/gpu/drm/nouveau/nouveau_gem.c b/drivers/gpu/drm/nouveau/nouveau_gem.c
index 0bd7164bc817..7f083c95f422 100644
--- a/drivers/gpu/drm/nouveau/nouveau_gem.c
+++ b/drivers/gpu/drm/nouveau/nouveau_gem.c
@@ -119,7 +119,7 @@ nouveau_gem_object_unmap(struct nouveau_bo *nvbo, struct nvkm_vma *vma)
        const bool mapped = nvbo->bo.mem.mem_type != TTM_PL_SYSTEM;
        struct reservation_object *resv = nvbo->bo.resv;
        struct reservation_object_list *fobj;
-        struct fence *fence = NULL;
+        struct dma_fence *fence = NULL;
        fobj = reservation_object_get_list(resv);
diff --git a/drivers/gpu/drm/nouveau/nv04_fence.c b/drivers/gpu/drm/nouveau/nv04_fence.c
index 1915b7b82a59..fa8f2375c398 100644
--- a/drivers/gpu/drm/nouveau/nv04_fence.c
+++ b/drivers/gpu/drm/nouveau/nv04_fence.c
@@ -110,6 +110,6 @@ nv04_fence_create(struct nouveau_drm *drm)
        priv->base.context_new = nv04_fence_context_new;
        priv->base.context_del = nv04_fence_context_del;
        priv->base.contexts = 15;
-        priv->base.context_base = fence_context_alloc(priv->base.contexts);
+        priv->base.context_base = dma_fence_context_alloc(priv->base.contexts);
        return 0;
 }
diff --git a/drivers/gpu/drm/nouveau/nv10_fence.c b/drivers/gpu/drm/nouveau/nv10_fence.c
index 4e3de34ff6f4..f99fcf56928a 100644
--- a/drivers/gpu/drm/nouveau/nv10_fence.c
+++ b/drivers/gpu/drm/nouveau/nv10_fence.c
@@ -107,7 +107,7 @@ nv10_fence_create(struct nouveau_drm *drm)
        priv->base.context_new = nv10_fence_context_new;
        priv->base.context_del = nv10_fence_context_del;
        priv->base.contexts = 31;
-        priv->base.context_base = fence_context_alloc(priv->base.contexts);
+        priv->base.context_base = dma_fence_context_alloc(priv->base.contexts);
        spin_lock_init(&priv->lock);
        return 0;
 }
diff --git a/drivers/gpu/drm/nouveau/nv17_fence.c b/drivers/gpu/drm/nouveau/nv17_fence.c
index 7d5e562a55c5..79bc01111351 100644
--- a/drivers/gpu/drm/nouveau/nv17_fence.c
+++ b/drivers/gpu/drm/nouveau/nv17_fence.c
@@ -126,7 +126,7 @@ nv17_fence_create(struct nouveau_drm *drm)
        priv->base.context_new = nv17_fence_context_new;
        priv->base.context_del = nv10_fence_context_del;
        priv->base.contexts = 31;
-        priv->base.context_base = fence_context_alloc(priv->base.contexts);
+        priv->base.context_base = dma_fence_context_alloc(priv->base.contexts);
        spin_lock_init(&priv->lock);
        ret = nouveau_bo_new(drm->dev, 4096, 0x1000, TTM_PL_FLAG_VRAM,
diff --git a/drivers/gpu/drm/nouveau/nv50_fence.c b/drivers/gpu/drm/nouveau/nv50_fence.c
index 4d6f202b7770..8c5295414578 100644
--- a/drivers/gpu/drm/nouveau/nv50_fence.c
+++ b/drivers/gpu/drm/nouveau/nv50_fence.c
@@ -97,7 +97,7 @@ nv50_fence_create(struct nouveau_drm *drm)
        priv->base.context_new = nv50_fence_context_new;
        priv->base.context_del = nv10_fence_context_del;
        priv->base.contexts = 127;
-        priv->base.context_base = fence_context_alloc(priv->base.contexts);
+        priv->base.context_base = dma_fence_context_alloc(priv->base.contexts);
        spin_lock_init(&priv->lock);
        ret = nouveau_bo_new(drm->dev, 4096, 0x1000, TTM_PL_FLAG_VRAM,
diff --git a/drivers/gpu/drm/nouveau/nv84_fence.c b/drivers/gpu/drm/nouveau/nv84_fence.c
index 18bde9d8e6d6..23ef04b4e0b2 100644
--- a/drivers/gpu/drm/nouveau/nv84_fence.c
+++ b/drivers/gpu/drm/nouveau/nv84_fence.c
@@ -229,7 +229,7 @@ nv84_fence_create(struct nouveau_drm *drm)
        priv->base.context_del = nv84_fence_context_del;
        priv->base.contexts = fifo->nr;
-        priv->base.context_base = fence_context_alloc(priv->base.contexts);
+        priv->base.context_base = dma_fence_context_alloc(priv->base.contexts);
        priv->base.uevent = true;
        /* Use VRAM if there is any ; otherwise fallback to system memory */
diff --git a/drivers/gpu/drm/qxl/qxl_drv.h b/drivers/gpu/drm/qxl/qxl_drv.h
index 5f3e5ad99de7..84995ebc6ffc 100644
--- a/drivers/gpu/drm/qxl/qxl_drv.h
+++ b/drivers/gpu/drm/qxl/qxl_drv.h
@@ -31,7 +31,7 @@
 * Definitions taken from spice-protocol, plus kernel driver specific bits.
 */
-#include <linux/fence.h>
+#include <linux/dma-fence.h>
 #include <linux/workqueue.h>
 #include <linux/firmware.h>
 #include <linux/platform_device.h>
@@ -190,7 +190,7 @@ enum {
 * spice-protocol/qxl_dev.h */
 #define QXL_MAX_RES 96
 struct qxl_release {
-        struct fence base;
+        struct dma_fence base;
        int id;
        int type;
diff --git a/drivers/gpu/drm/qxl/qxl_release.c b/drivers/gpu/drm/qxl/qxl_release.c
index cd83f050cf3e..50b4e522f05f 100644
--- a/drivers/gpu/drm/qxl/qxl_release.c
+++ b/drivers/gpu/drm/qxl/qxl_release.c
@@ -21,7 +21,7 @@
 */
 #include "qxl_drv.h"
 #include "qxl_object.h"
-#include <trace/events/fence.h>
+#include <trace/events/dma_fence.h>
 /*
 * drawable cmd cache - allocate a bunch of VRAM pages, suballocate
@@ -40,23 +40,24 @@
 static const int release_size_per_bo[] = { RELEASE_SIZE, SURFACE_RELEASE_SIZE, RELEASE_SIZE };
 static const int releases_per_bo[] = { RELEASES_PER_BO, SURFACE_RELEASES_PER_BO, RELEASES_PER_BO };
-static const char *qxl_get_driver_name(struct fence *fence)
+static const char *qxl_get_driver_name(struct dma_fence *fence)
 {
        return "qxl";
 }
-static const char *qxl_get_timeline_name(struct fence *fence)
+static const char *qxl_get_timeline_name(struct dma_fence *fence)
 {
        return "release";
 }
-static bool qxl_nop_signaling(struct fence *fence)
+static bool qxl_nop_signaling(struct dma_fence *fence)
 {
        /* fences are always automatically signaled, so just pretend we did this.. */
        return true;
 }
-static long qxl_fence_wait(struct fence *fence, bool intr, signed long timeout)
+static long qxl_fence_wait(struct dma_fence *fence, bool intr,
+                           signed long timeout)
 {
        struct qxl_device *qdev;
        struct qxl_release *release;
@@ -71,7 +72,7 @@ static long qxl_fence_wait(struct fence *fence, bool intr, signed long timeout)
 retry:
        sc++;
-        if (fence_is_signaled(fence))
+        if (dma_fence_is_signaled(fence))
                goto signaled;
        qxl_io_notify_oom(qdev);
@@ -80,11 +81,11 @@ retry:
                if (!qxl_queue_garbage_collect(qdev, true))
                        break;
-                if (fence_is_signaled(fence))
+                if (dma_fence_is_signaled(fence))
                        goto signaled;
        }
-        if (fence_is_signaled(fence))
+        if (dma_fence_is_signaled(fence))
                goto signaled;
        if (have_drawable_releases || sc < 4) {
@@ -96,9 +97,9 @@ retry:
                        return 0;
                if (have_drawable_releases && sc > 300) {
-                        FENCE_WARN(fence, "failed to wait on release %llu "
+                        DMA_FENCE_WARN(fence, "failed to wait on release %llu "
-                                          "after spincount %d\n",
+                                       "after spincount %d\n",
-                                          fence->context & ~0xf0000000, sc);
+                                       fence->context & ~0xf0000000, sc);
                        goto signaled;
                }
                goto retry;
@@ -115,7 +116,7 @@ signaled:
        return end - cur;
 }
-static const struct fence_ops qxl_fence_ops = {
+static const struct dma_fence_ops qxl_fence_ops = {
        .get_driver_name = qxl_get_driver_name,
        .get_timeline_name = qxl_get_timeline_name,
        .enable_signaling = qxl_nop_signaling,
@@ -192,8 +193,8 @@ qxl_release_free(struct qxl_device *qdev,
                WARN_ON(list_empty(&release->bos));
                qxl_release_free_list(release);
-                fence_signal(&release->base);
+                dma_fence_signal(&release->base);
-                fence_put(&release->base);
+                dma_fence_put(&release->base);
        } else {
                qxl_release_free_list(release);
                kfree(release);
@@ -453,9 +454,9 @@ void qxl_release_fence_buffer_objects(struct qxl_release *release)
         * Since we never really allocated a context and we don't want to conflict,
         * set the highest bits. This will break if we really allow exporting of dma-bufs.
         */
-        fence_init(&release->base, &qxl_fence_ops, &qdev->release_lock,
+        dma_fence_init(&release->base, &qxl_fence_ops, &qdev->release_lock,
-                   release->id | 0xf0000000, release->base.seqno);
+                       release->id | 0xf0000000, release->base.seqno);
-        trace_fence_emit(&release->base);
+        trace_dma_fence_emit(&release->base);
        driver = bdev->driver;
        glob = bo->glob;
diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h
index 1b0dcad916b0..44e0c5ed6418 100644
--- a/drivers/gpu/drm/radeon/radeon.h
+++ b/drivers/gpu/drm/radeon/radeon.h
@@ -66,7 +66,7 @@
 #include <linux/kref.h>
 #include <linux/interval_tree.h>
 #include <linux/hashtable.h>
-#include <linux/fence.h>
+#include <linux/dma-fence.h>
 #include <ttm/ttm_bo_api.h>
 #include <ttm/ttm_bo_driver.h>
@@ -367,7 +367,7 @@ struct radeon_fence_driver {
 };
 struct radeon_fence {
-        struct fence            base;
+        struct dma_fence                base;
        struct radeon_device    *rdev;
        uint64_t                seq;
@@ -746,7 +746,7 @@ struct radeon_flip_work {
        uint64_t                        base;
        struct drm_pending_vblank_event *event;
        struct radeon_bo                *old_rbo;
-        struct fence                    *fence;
+        struct dma_fence                *fence;
        bool                            async;
 };
@@ -2514,9 +2514,9 @@ void cik_mm_wdoorbell(struct radeon_device *rdev, u32 index, u32 v);
 /*
 * Cast helper
 */
-extern const struct fence_ops radeon_fence_ops;
+extern const struct dma_fence_ops radeon_fence_ops;
-static inline struct radeon_fence *to_radeon_fence(struct fence *f)
+static inline struct radeon_fence *to_radeon_fence(struct dma_fence *f)
 {
        struct radeon_fence *__f = container_of(f, struct radeon_fence, base);
diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c
index eb92aef46e3c..36b7ac7e57e5 100644
--- a/drivers/gpu/drm/radeon/radeon_device.c
+++ b/drivers/gpu/drm/radeon/radeon_device.c
@@ -1320,7 +1320,7 @@ int radeon_device_init(struct radeon_device *rdev,
        for (i = 0; i < RADEON_NUM_RINGS; i++) {
                rdev->ring[i].idx = i;
        }
-        rdev->fence_context = fence_context_alloc(RADEON_NUM_RINGS);
+        rdev->fence_context = dma_fence_context_alloc(RADEON_NUM_RINGS);
        DRM_INFO("initializing kernel modesetting (%s 0x%04X:0x%04X 0x%04X:0x%04X 0x%02X).\n",
                 radeon_family_name[rdev->family], pdev->vendor, pdev->device,
diff --git a/drivers/gpu/drm/radeon/radeon_display.c b/drivers/gpu/drm/radeon/radeon_display.c
index cdb8cb568c15..e7409e8a9f87 100644
--- a/drivers/gpu/drm/radeon/radeon_display.c
+++ b/drivers/gpu/drm/radeon/radeon_display.c
@@ -437,7 +437,7 @@ static void radeon_flip_work_func(struct work_struct *__work)
                                down_read(&rdev->exclusive_lock);
                        }
                } else
-                        r = fence_wait(work->fence, false);
+                        r = dma_fence_wait(work->fence, false);
                if (r)
                        DRM_ERROR("failed to wait on page flip fence (%d)!\n", r);
@@ -447,7 +447,7 @@ static void radeon_flip_work_func(struct work_struct *__work)
                 * confused about which BO the CRTC is scanning out
                 */
-                fence_put(work->fence);
+                dma_fence_put(work->fence);
                work->fence = NULL;
        }
@@ -542,7 +542,7 @@ static int radeon_crtc_page_flip_target(struct drm_crtc *crtc,
                DRM_ERROR("failed to pin new rbo buffer before flip\n");
                goto cleanup;
        }
-        work->fence = fence_get(reservation_object_get_excl(new_rbo->tbo.resv));
+        work->fence = dma_fence_get(reservation_object_get_excl(new_rbo->tbo.resv));
        radeon_bo_get_tiling_flags(new_rbo, &tiling_flags, NULL);
        radeon_bo_unreserve(new_rbo);
@@ -617,7 +617,7 @@ pflip_cleanup:
 cleanup:
        drm_gem_object_unreference_unlocked(&work->old_rbo->gem_base);
-        fence_put(work->fence);
+        dma_fence_put(work->fence);
        kfree(work);
        return r;
 }
diff --git a/drivers/gpu/drm/radeon/radeon_fence.c b/drivers/gpu/drm/radeon/radeon_fence.c
index 7ef075acde9c..ef09f0a63754 100644
--- a/drivers/gpu/drm/radeon/radeon_fence.c
+++ b/drivers/gpu/drm/radeon/radeon_fence.c
@@ -141,8 +141,10 @@ int radeon_fence_emit(struct radeon_device *rdev,
        (*fence)->seq = seq = ++rdev->fence_drv[ring].sync_seq[ring];
        (*fence)->ring = ring;
        (*fence)->is_vm_update = false;
-        fence_init(&(*fence)->base, &radeon_fence_ops,
+        dma_fence_init(&(*fence)->base, &radeon_fence_ops,
-                   &rdev->fence_queue.lock, rdev->fence_context + ring, seq);
+                       &rdev->fence_queue.lock,
+                       rdev->fence_context + ring,
+                       seq);
        radeon_fence_ring_emit(rdev, ring, *fence);
        trace_radeon_fence_emit(rdev->ddev, ring, (*fence)->seq);
        radeon_fence_schedule_check(rdev, ring);
@@ -169,18 +171,18 @@ static int radeon_fence_check_signaled(wait_queue_t *wait, unsigned mode, int fl
         */
        seq = atomic64_read(&fence->rdev->fence_drv[fence->ring].last_seq);
        if (seq >= fence->seq) {
-                int ret = fence_signal_locked(&fence->base);
+                int ret = dma_fence_signal_locked(&fence->base);
                if (!ret)
-                        FENCE_TRACE(&fence->base, "signaled from irq context\n");
+                        DMA_FENCE_TRACE(&fence->base, "signaled from irq context\n");
                else
-                        FENCE_TRACE(&fence->base, "was already signaled\n");
+                        DMA_FENCE_TRACE(&fence->base, "was already signaled\n");
                radeon_irq_kms_sw_irq_put(fence->rdev, fence->ring);
                __remove_wait_queue(&fence->rdev->fence_queue, &fence->fence_wake);
-                fence_put(&fence->base);
+                dma_fence_put(&fence->base);
        } else
-                FENCE_TRACE(&fence->base, "pending\n");
+                DMA_FENCE_TRACE(&fence->base, "pending\n");
        return 0;
 }
@@ -351,7 +353,7 @@ static bool radeon_fence_seq_signaled(struct radeon_device *rdev,
        return false;
 }
-static bool radeon_fence_is_signaled(struct fence *f)
+static bool radeon_fence_is_signaled(struct dma_fence *f)
 {
        struct radeon_fence *fence = to_radeon_fence(f);
        struct radeon_device *rdev = fence->rdev;
@@ -381,7 +383,7 @@ static bool radeon_fence_is_signaled(struct fence *f)
 * to fence_queue that checks if this fence is signaled, and if so it
 * signals the fence and removes itself.
 */
-static bool radeon_fence_enable_signaling(struct fence *f)
+static bool radeon_fence_enable_signaling(struct dma_fence *f)
 {
        struct radeon_fence *fence = to_radeon_fence(f);
        struct radeon_device *rdev = fence->rdev;
@@ -414,9 +416,9 @@ static bool radeon_fence_enable_signaling(struct fence *f)
        fence->fence_wake.private = NULL;
        fence->fence_wake.func = radeon_fence_check_signaled;
        __add_wait_queue(&rdev->fence_queue, &fence->fence_wake);
-        fence_get(f);
+        dma_fence_get(f);
-        FENCE_TRACE(&fence->base, "armed on ring %i!\n", fence->ring);
+        DMA_FENCE_TRACE(&fence->base, "armed on ring %i!\n", fence->ring);
        return true;
 }
@@ -436,9 +438,9 @@ bool radeon_fence_signaled(struct radeon_fence *fence)
        if (radeon_fence_seq_signaled(fence->rdev, fence->seq, fence->ring)) {
                int ret;
-                ret = fence_signal(&fence->base);
+                ret = dma_fence_signal(&fence->base);
                if (!ret)
-                        FENCE_TRACE(&fence->base, "signaled from radeon_fence_signaled\n");
+                        DMA_FENCE_TRACE(&fence->base, "signaled from radeon_fence_signaled\n");
                return true;
        }
        return false;
@@ -552,7 +554,7 @@ long radeon_fence_wait_timeout(struct radeon_fence *fence, bool intr, long timeo
         * exclusive_lock is not held in that case.
         */
        if (WARN_ON_ONCE(!to_radeon_fence(&fence->base)))
-                return fence_wait(&fence->base, intr);
+                return dma_fence_wait(&fence->base, intr);
        seq[fence->ring] = fence->seq;
        r = radeon_fence_wait_seq_timeout(fence->rdev, seq, intr, timeout);
@@ -560,9 +562,9 @@ long radeon_fence_wait_timeout(struct radeon_fence *fence, bool intr, long timeo
                return r;
        }
-        r_sig = fence_signal(&fence->base);
+        r_sig = dma_fence_signal(&fence->base);
        if (!r_sig)
-                FENCE_TRACE(&fence->base, "signaled from fence_wait\n");
+                DMA_FENCE_TRACE(&fence->base, "signaled from fence_wait\n");
        return r;
 }
@@ -697,7 +699,7 @@ int radeon_fence_wait_empty(struct radeon_device *rdev, int ring)
 */
 struct radeon_fence *radeon_fence_ref(struct radeon_fence *fence)
 {
-        fence_get(&fence->base);
+        dma_fence_get(&fence->base);
        return fence;
 }
@@ -714,7 +716,7 @@ void radeon_fence_unref(struct radeon_fence **fence)
        *fence = NULL;
        if (tmp) {
-                fence_put(&tmp->base);
+                dma_fence_put(&tmp->base);
        }
 }
@@ -1028,12 +1030,12 @@ int radeon_debugfs_fence_init(struct radeon_device *rdev)
 #endif
 }
-static const char *radeon_fence_get_driver_name(struct fence *fence)
+static const char *radeon_fence_get_driver_name(struct dma_fence *fence)
 {
        return "radeon";
 }
-static const char *radeon_fence_get_timeline_name(struct fence *f)
+static const char *radeon_fence_get_timeline_name(struct dma_fence *f)
 {
        struct radeon_fence *fence = to_radeon_fence(f);
        switch (fence->ring) {
@@ -1051,16 +1053,16 @@ static const char *radeon_fence_get_timeline_name(struct fence *f)
 static inline bool radeon_test_signaled(struct radeon_fence *fence)
 {
-        return test_bit(FENCE_FLAG_SIGNALED_BIT, &fence->base.flags);
+        return test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->base.flags);
 }
 struct radeon_wait_cb {
-        struct fence_cb base;
+        struct dma_fence_cb base;
        struct task_struct *task;
 };
 static void
-radeon_fence_wait_cb(struct fence *fence, struct fence_cb *cb)
+radeon_fence_wait_cb(struct dma_fence *fence, struct dma_fence_cb *cb)
 {
        struct radeon_wait_cb *wait =
                container_of(cb, struct radeon_wait_cb, base);
@@ -1068,7 +1070,7 @@ radeon_fence_wait_cb(struct fence *fence, struct fence_cb *cb)
        wake_up_process(wait->task);
 }
-static signed long radeon_fence_default_wait(struct fence *f, bool intr,
+static signed long radeon_fence_default_wait(struct dma_fence *f, bool intr,
                                             signed long t)
 {
        struct radeon_fence *fence = to_radeon_fence(f);
@@ -1077,7 +1079,7 @@ static signed long radeon_fence_default_wait(struct fence *f, bool intr,
        cb.task = current;
-        if (fence_add_callback(f, &cb.base, radeon_fence_wait_cb))
+        if (dma_fence_add_callback(f, &cb.base, radeon_fence_wait_cb))
                return t;
        while (t > 0) {
@@ -1105,12 +1107,12 @@ static signed long radeon_fence_default_wait(struct fence *f, bool intr,
        }
        __set_current_state(TASK_RUNNING);
-        fence_remove_callback(f, &cb.base);
+        dma_fence_remove_callback(f, &cb.base);
        return t;
 }
-const struct fence_ops radeon_fence_ops = {
+const struct dma_fence_ops radeon_fence_ops = {
        .get_driver_name = radeon_fence_get_driver_name,
        .get_timeline_name = radeon_fence_get_timeline_name,
        .enable_signaling = radeon_fence_enable_signaling,
diff --git a/drivers/gpu/drm/radeon/radeon_sync.c b/drivers/gpu/drm/radeon/radeon_sync.c
index 02ac8a1de4ff..be5d7a38d3aa 100644
--- a/drivers/gpu/drm/radeon/radeon_sync.c
+++ b/drivers/gpu/drm/radeon/radeon_sync.c
@@ -92,7 +92,7 @@ int radeon_sync_resv(struct radeon_device *rdev,
                     bool shared)
 {
        struct reservation_object_list *flist;
-        struct fence *f;
+        struct dma_fence *f;
        struct radeon_fence *fence;
        unsigned i;
        int r = 0;
@@ -103,7 +103,7 @@ int radeon_sync_resv(struct radeon_device *rdev,
        if (fence && fence->rdev == rdev)
                radeon_sync_fence(sync, fence);
        else if (f)
-                r = fence_wait(f, true);
+                r = dma_fence_wait(f, true);
        flist = reservation_object_get_list(resv);
        if (shared || !flist || r)
@@ -116,7 +116,7 @@ int radeon_sync_resv(struct radeon_device *rdev,
                if (fence && fence->rdev == rdev)
                        radeon_sync_fence(sync, fence);
                else
-                        r = fence_wait(f, true);
+                        r = dma_fence_wait(f, true);
                if (r)
                        break;
diff --git a/drivers/gpu/drm/radeon/radeon_uvd.c b/drivers/gpu/drm/radeon/radeon_uvd.c
index 0cd0e7bdee55..d34d1cf33895 100644
--- a/drivers/gpu/drm/radeon/radeon_uvd.c
+++ b/drivers/gpu/drm/radeon/radeon_uvd.c
@@ -467,7 +467,7 @@ static int radeon_uvd_cs_msg(struct radeon_cs_parser *p, struct radeon_bo *bo,
 {
        int32_t *msg, msg_type, handle;
        unsigned img_size = 0;
-        struct fence *f;
+        struct dma_fence *f;
        void *ptr;
        int i, r;
diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c
index fc6217dfe401..915e0d1c316a 100644
--- a/drivers/gpu/drm/ttm/ttm_bo.c
+++ b/drivers/gpu/drm/ttm/ttm_bo.c
@@ -148,7 +148,7 @@ static void ttm_bo_release_list(struct kref *list_kref)
        BUG_ON(!list_empty(&bo->ddestroy));
        ttm_tt_destroy(bo->ttm);
        atomic_dec(&bo->glob->bo_count);
-        fence_put(bo->moving);
+        dma_fence_put(bo->moving);
        if (bo->resv == &bo->ttm_resv)
                reservation_object_fini(&bo->ttm_resv);
        mutex_destroy(&bo->wu_mutex);
@@ -426,20 +426,20 @@ static void ttm_bo_cleanup_memtype_use(struct ttm_buffer_object *bo)
 static void ttm_bo_flush_all_fences(struct ttm_buffer_object *bo)
 {
        struct reservation_object_list *fobj;
-        struct fence *fence;
+        struct dma_fence *fence;
        int i;
        fobj = reservation_object_get_list(bo->resv);
        fence = reservation_object_get_excl(bo->resv);
        if (fence && !fence->ops->signaled)
-                fence_enable_sw_signaling(fence);
+                dma_fence_enable_sw_signaling(fence);
        for (i = 0; fobj && i < fobj->shared_count; ++i) {
                fence = rcu_dereference_protected(fobj->shared[i],
                                        reservation_object_held(bo->resv));
                if (!fence->ops->signaled)
-                        fence_enable_sw_signaling(fence);
+                        dma_fence_enable_sw_signaling(fence);
        }
 }
@@ -792,11 +792,11 @@ static int ttm_bo_add_move_fence(struct ttm_buffer_object *bo,
                                 struct ttm_mem_type_manager *man,
                                 struct ttm_mem_reg *mem)
 {
-        struct fence *fence;
+        struct dma_fence *fence;
        int ret;
        spin_lock(&man->move_lock);
-        fence = fence_get(man->move);
+        fence = dma_fence_get(man->move);
        spin_unlock(&man->move_lock);
        if (fence) {
@@ -806,7 +806,7 @@ static int ttm_bo_add_move_fence(struct ttm_buffer_object *bo,
                if (unlikely(ret))
                        return ret;
-                fence_put(bo->moving);
+                dma_fence_put(bo->moving);
                bo->moving = fence;
        }
@@ -1286,7 +1286,7 @@ static int ttm_bo_force_list_clean(struct ttm_bo_device *bdev,
 {
        struct ttm_mem_type_manager *man = &bdev->man[mem_type];
        struct ttm_bo_global *glob = bdev->glob;
-        struct fence *fence;
+        struct dma_fence *fence;
        int ret;
        /*
@@ -1309,12 +1309,12 @@ static int ttm_bo_force_list_clean(struct ttm_bo_device *bdev,
        spin_unlock(&glob->lru_lock);
        spin_lock(&man->move_lock);
-        fence = fence_get(man->move);
+        fence = dma_fence_get(man->move);
        spin_unlock(&man->move_lock);
        if (fence) {
-                ret = fence_wait(fence, false);
+                ret = dma_fence_wait(fence, false);
-                fence_put(fence);
+                dma_fence_put(fence);
                if (ret) {
                        if (allow_errors) {
                                return ret;
@@ -1343,7 +1343,7 @@ int ttm_bo_clean_mm(struct ttm_bo_device *bdev, unsigned mem_type)
                       mem_type);
                return ret;
        }
-        fence_put(man->move);
+        dma_fence_put(man->move);
        man->use_type = false;
        man->has_type = false;
diff --git a/drivers/gpu/drm/ttm/ttm_bo_util.c b/drivers/gpu/drm/ttm/ttm_bo_util.c
index bf6e21655c57..d0459b392e5e 100644
--- a/drivers/gpu/drm/ttm/ttm_bo_util.c
+++ b/drivers/gpu/drm/ttm/ttm_bo_util.c
@@ -644,7 +644,7 @@ void ttm_bo_kunmap(struct ttm_bo_kmap_obj *map)
 EXPORT_SYMBOL(ttm_bo_kunmap);
 int ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo,
-                              struct fence *fence,
+                              struct dma_fence *fence,
                              bool evict,
                              struct ttm_mem_reg *new_mem)
 {
@@ -674,8 +674,8 @@ int ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo,
                 * operation has completed.
                 */
-                fence_put(bo->moving);
+                dma_fence_put(bo->moving);
-                bo->moving = fence_get(fence);
+                bo->moving = dma_fence_get(fence);
                ret = ttm_buffer_object_transfer(bo, &ghost_obj);
                if (ret)
@@ -706,7 +706,7 @@ int ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo,
 EXPORT_SYMBOL(ttm_bo_move_accel_cleanup);
 int ttm_bo_pipeline_move(struct ttm_buffer_object *bo,
-                         struct fence *fence, bool evict,
+                         struct dma_fence *fence, bool evict,
                         struct ttm_mem_reg *new_mem)
 {
        struct ttm_bo_device *bdev = bo->bdev;
@@ -730,8 +730,8 @@ int ttm_bo_pipeline_move(struct ttm_buffer_object *bo,
                 * operation has completed.
                 */
-                fence_put(bo->moving);
+                dma_fence_put(bo->moving);
-                bo->moving = fence_get(fence);
+                bo->moving = dma_fence_get(fence);
                ret = ttm_buffer_object_transfer(bo, &ghost_obj);
                if (ret)
@@ -761,16 +761,16 @@ int ttm_bo_pipeline_move(struct ttm_buffer_object *bo,
                 */
                spin_lock(&from->move_lock);
-                if (!from->move || fence_is_later(fence, from->move)) {
+                if (!from->move || dma_fence_is_later(fence, from->move)) {
-                        fence_put(from->move);
+                        dma_fence_put(from->move);
-                        from->move = fence_get(fence);
+                        from->move = dma_fence_get(fence);
                }
                spin_unlock(&from->move_lock);
                ttm_bo_free_old_node(bo);
-                fence_put(bo->moving);
+                dma_fence_put(bo->moving);
-                bo->moving = fence_get(fence);
+                bo->moving = dma_fence_get(fence);
        } else {
                /**
diff --git a/drivers/gpu/drm/ttm/ttm_bo_vm.c b/drivers/gpu/drm/ttm/ttm_bo_vm.c
index a6ed9d5e5167..4748aedc933a 100644
--- a/drivers/gpu/drm/ttm/ttm_bo_vm.c
+++ b/drivers/gpu/drm/ttm/ttm_bo_vm.c
@@ -54,7 +54,7 @@ static int ttm_bo_vm_fault_idle(struct ttm_buffer_object *bo,
        /*
         * Quick non-stalling check for idle.
         */
-        if (fence_is_signaled(bo->moving))
+        if (dma_fence_is_signaled(bo->moving))
                goto out_clear;
        /*
@@ -67,14 +67,14 @@ static int ttm_bo_vm_fault_idle(struct ttm_buffer_object *bo,
                        goto out_unlock;
                up_read(&vma->vm_mm->mmap_sem);
-                (void) fence_wait(bo->moving, true);
+                (void) dma_fence_wait(bo->moving, true);
                goto out_unlock;
        }
        /*
         * Ordinary wait.
         */
-        ret = fence_wait(bo->moving, true);
+        ret = dma_fence_wait(bo->moving, true);
        if (unlikely(ret != 0)) {
                ret = (ret != -ERESTARTSYS) ? VM_FAULT_SIGBUS :
                        VM_FAULT_NOPAGE;
@@ -82,7 +82,7 @@ static int ttm_bo_vm_fault_idle(struct ttm_buffer_object *bo,
        }
 out_clear:
-        fence_put(bo->moving);
+        dma_fence_put(bo->moving);
        bo->moving = NULL;
 out_unlock:
diff --git a/drivers/gpu/drm/ttm/ttm_execbuf_util.c b/drivers/gpu/drm/ttm/ttm_execbuf_util.c
index a80717b35dc6..d35bc491e8de 100644
--- a/drivers/gpu/drm/ttm/ttm_execbuf_util.c
+++ b/drivers/gpu/drm/ttm/ttm_execbuf_util.c
@@ -179,7 +179,8 @@ int ttm_eu_reserve_buffers(struct ww_acquire_ctx *ticket,
 EXPORT_SYMBOL(ttm_eu_reserve_buffers);
 void ttm_eu_fence_buffer_objects(struct ww_acquire_ctx *ticket,
-                                 struct list_head *list, struct fence *fence)
+                                 struct list_head *list,
+                                 struct dma_fence *fence)
 {
        struct ttm_validate_buffer *entry;
        struct ttm_buffer_object *bo;
diff --git a/drivers/gpu/drm/vgem/vgem_fence.c b/drivers/gpu/drm/vgem/vgem_fence.c
index 5c57c1ffa1f9..488909a21ed8 100644
--- a/drivers/gpu/drm/vgem/vgem_fence.c
+++ b/drivers/gpu/drm/vgem/vgem_fence.c
@@ -28,56 +28,57 @@
 #define VGEM_FENCE_TIMEOUT (10*HZ)
 struct vgem_fence {
-        struct fence base;
+        struct dma_fence base;
        struct spinlock lock;
        struct timer_list timer;
 };
-static const char *vgem_fence_get_driver_name(struct fence *fence)
+static const char *vgem_fence_get_driver_name(struct dma_fence *fence)
 {
        return "vgem";
 }
-static const char *vgem_fence_get_timeline_name(struct fence *fence)
+static const char *vgem_fence_get_timeline_name(struct dma_fence *fence)
 {
        return "unbound";
 }
-static bool vgem_fence_signaled(struct fence *fence)
+static bool vgem_fence_signaled(struct dma_fence *fence)
 {
        return false;
 }
-static bool vgem_fence_enable_signaling(struct fence *fence)
+static bool vgem_fence_enable_signaling(struct dma_fence *fence)
 {
        return true;
 }
-static void vgem_fence_release(struct fence *base)
+static void vgem_fence_release(struct dma_fence *base)
 {
        struct vgem_fence *fence = container_of(base, typeof(*fence), base);
        del_timer_sync(&fence->timer);
-        fence_free(&fence->base);
+        dma_fence_free(&fence->base);
 }
-static void vgem_fence_value_str(struct fence *fence, char *str, int size)
+static void vgem_fence_value_str(struct dma_fence *fence, char *str, int size)
 {
        snprintf(str, size, "%u", fence->seqno);
 }
-static void vgem_fence_timeline_value_str(struct fence *fence, char *str,
+static void vgem_fence_timeline_value_str(struct dma_fence *fence, char *str,
                                          int size)
 {
-        snprintf(str, size, "%u", fence_is_signaled(fence) ? fence->seqno : 0);
+        snprintf(str, size, "%u",
+                 dma_fence_is_signaled(fence) ? fence->seqno : 0);
 }
-static const struct fence_ops vgem_fence_ops = {
+static const struct dma_fence_ops vgem_fence_ops = {
        .get_driver_name = vgem_fence_get_driver_name,
        .get_timeline_name = vgem_fence_get_timeline_name,
        .enable_signaling = vgem_fence_enable_signaling,
        .signaled = vgem_fence_signaled,
-        .wait = fence_default_wait,
+        .wait = dma_fence_default_wait,
        .release = vgem_fence_release,
        .fence_value_str = vgem_fence_value_str,
@@ -88,11 +89,11 @@ static void vgem_fence_timeout(unsigned long data)
 {
        struct vgem_fence *fence = (struct vgem_fence *)data;
-        fence_signal(&fence->base);
+        dma_fence_signal(&fence->base);
 }
-static struct fence *vgem_fence_create(struct vgem_file *vfile,
+static struct dma_fence *vgem_fence_create(struct vgem_file *vfile,
-                                       unsigned int flags)
+                                           unsigned int flags)
 {
        struct vgem_fence *fence;
@@ -101,8 +102,8 @@ static struct fence *vgem_fence_create(struct vgem_file *vfile,
                return NULL;
        spin_lock_init(&fence->lock);
-        fence_init(&fence->base, &vgem_fence_ops, &fence->lock,
+        dma_fence_init(&fence->base, &vgem_fence_ops, &fence->lock,
-                   fence_context_alloc(1), 1);
+                       dma_fence_context_alloc(1), 1);
        setup_timer(&fence->timer, vgem_fence_timeout, (unsigned long)fence);
@@ -157,7 +158,7 @@ int vgem_fence_attach_ioctl(struct drm_device *dev,
        struct vgem_file *vfile = file->driver_priv;
        struct reservation_object *resv;
        struct drm_gem_object *obj;
-        struct fence *fence;
+        struct dma_fence *fence;
        int ret;
        if (arg->flags & ~VGEM_FENCE_WRITE)
@@ -209,8 +210,8 @@ int vgem_fence_attach_ioctl(struct drm_device *dev,
        }
 err_fence:
        if (ret) {
-                fence_signal(fence);
+                dma_fence_signal(fence);
-                fence_put(fence);
+                dma_fence_put(fence);
        }
 err:
        drm_gem_object_unreference_unlocked(obj);
@@ -239,7 +240,7 @@ int vgem_fence_signal_ioctl(struct drm_device *dev,
 {
        struct vgem_file *vfile = file->driver_priv;
        struct drm_vgem_fence_signal *arg = data;
-        struct fence *fence;
+        struct dma_fence *fence;
        int ret = 0;
        if (arg->flags)
@@ -253,11 +254,11 @@ int vgem_fence_signal_ioctl(struct drm_device *dev,
        if (IS_ERR(fence))
                return PTR_ERR(fence);
-        if (fence_is_signaled(fence))
+        if (dma_fence_is_signaled(fence))
                ret = -ETIMEDOUT;
-        fence_signal(fence);
+        dma_fence_signal(fence);
-        fence_put(fence);
+        dma_fence_put(fence);
        return ret;
 }
@@ -271,8 +272,8 @@ int vgem_fence_open(struct vgem_file *vfile)
 static int __vgem_fence_idr_fini(int id, void *p, void *data)
 {
-        fence_signal(p);
+        dma_fence_signal(p);
-        fence_put(p);
+        dma_fence_put(p);
        return 0;
 }
diff --git a/drivers/gpu/drm/virtio/virtgpu_drv.h b/drivers/gpu/drm/virtio/virtgpu_drv.h
index ae59080d63d1..ec1ebdcfe80b 100644
--- a/drivers/gpu/drm/virtio/virtgpu_drv.h
+++ b/drivers/gpu/drm/virtio/virtgpu_drv.h
@@ -82,7 +82,7 @@ struct virtio_gpu_fence_driver {
 };
 struct virtio_gpu_fence {
-        struct fence f;
+        struct dma_fence f;
        struct virtio_gpu_fence_driver *drv;
        struct list_head node;
        uint64_t seq;
diff --git a/drivers/gpu/drm/virtio/virtgpu_fence.c b/drivers/gpu/drm/virtio/virtgpu_fence.c
index f3f70fa8a4c7..23353521f903 100644
--- a/drivers/gpu/drm/virtio/virtgpu_fence.c
+++ b/drivers/gpu/drm/virtio/virtgpu_fence.c
@@ -26,22 +26,22 @@
 #include <drm/drmP.h>
 #include "virtgpu_drv.h"
-static const char *virtio_get_driver_name(struct fence *f)
+static const char *virtio_get_driver_name(struct dma_fence *f)
 {
        return "virtio_gpu";
 }
-static const char *virtio_get_timeline_name(struct fence *f)
+static const char *virtio_get_timeline_name(struct dma_fence *f)
 {
        return "controlq";
 }
-static bool virtio_enable_signaling(struct fence *f)
+static bool virtio_enable_signaling(struct dma_fence *f)
 {
        return true;
 }
-static bool virtio_signaled(struct fence *f)
+static bool virtio_signaled(struct dma_fence *f)
 {
        struct virtio_gpu_fence *fence = to_virtio_fence(f);
@@ -50,26 +50,26 @@ static bool virtio_signaled(struct fence *f)
        return false;
 }
-static void virtio_fence_value_str(struct fence *f, char *str, int size)
+static void virtio_fence_value_str(struct dma_fence *f, char *str, int size)
 {
        struct virtio_gpu_fence *fence = to_virtio_fence(f);
        snprintf(str, size, "%llu", fence->seq);
 }
-static void virtio_timeline_value_str(struct fence *f, char *str, int size)
+static void virtio_timeline_value_str(struct dma_fence *f, char *str, int size)
 {
        struct virtio_gpu_fence *fence = to_virtio_fence(f);
        snprintf(str, size, "%llu", (u64)atomic64_read(&fence->drv->last_seq));
 }
-static const struct fence_ops virtio_fence_ops = {
+static const struct dma_fence_ops virtio_fence_ops = {
        .get_driver_name     = virtio_get_driver_name,
        .get_timeline_name   = virtio_get_timeline_name,
        .enable_signaling    = virtio_enable_signaling,
        .signaled            = virtio_signaled,
-        .wait                = fence_default_wait,
+        .wait                = dma_fence_default_wait,
        .fence_value_str     = virtio_fence_value_str,
        .timeline_value_str  = virtio_timeline_value_str,
 };
@@ -88,9 +88,9 @@ int virtio_gpu_fence_emit(struct virtio_gpu_device *vgdev,
        spin_lock_irqsave(&drv->lock, irq_flags);
        (*fence)->drv = drv;
        (*fence)->seq = ++drv->sync_seq;
-        fence_init(&(*fence)->f, &virtio_fence_ops, &drv->lock,
+        dma_fence_init(&(*fence)->f, &virtio_fence_ops, &drv->lock,
-                   drv->context, (*fence)->seq);
+                       drv->context, (*fence)->seq);
-        fence_get(&(*fence)->f);
+        dma_fence_get(&(*fence)->f);
        list_add_tail(&(*fence)->node, &drv->fences);
        spin_unlock_irqrestore(&drv->lock, irq_flags);
@@ -111,9 +111,9 @@ void virtio_gpu_fence_event_process(struct virtio_gpu_device *vgdev,
        list_for_each_entry_safe(fence, tmp, &drv->fences, node) {
                if (last_seq < fence->seq)
                        continue;
-                fence_signal_locked(&fence->f);
+                dma_fence_signal_locked(&fence->f);
                list_del(&fence->node);
-                fence_put(&fence->f);
+                dma_fence_put(&fence->f);
        }
        spin_unlock_irqrestore(&drv->lock, irq_flags);
 }
diff --git a/drivers/gpu/drm/virtio/virtgpu_ioctl.c b/drivers/gpu/drm/virtio/virtgpu_ioctl.c
index 818478b4c4f0..61f3a963af95 100644
--- a/drivers/gpu/drm/virtio/virtgpu_ioctl.c
+++ b/drivers/gpu/drm/virtio/virtgpu_ioctl.c
@@ -172,7 +172,7 @@ static int virtio_gpu_execbuffer_ioctl(struct drm_device *dev, void *data,
        /* fence the command bo */
        virtio_gpu_unref_list(&validate_list);
        drm_free_large(buflist);
-        fence_put(&fence->f);
+        dma_fence_put(&fence->f);
        return 0;
 out_unresv:
@@ -298,7 +298,7 @@ static int virtio_gpu_resource_create_ioctl(struct drm_device *dev, void *data,
                drm_gem_object_release(obj);
                if (vgdev->has_virgl_3d) {
                        virtio_gpu_unref_list(&validate_list);
-                        fence_put(&fence->f);
+                        dma_fence_put(&fence->f);
                }
                return ret;
        }
@@ -309,13 +309,13 @@ static int virtio_gpu_resource_create_ioctl(struct drm_device *dev, void *data,
        if (vgdev->has_virgl_3d) {
                virtio_gpu_unref_list(&validate_list);
-                fence_put(&fence->f);
+                dma_fence_put(&fence->f);
        }
        return 0;
 fail_unref:
        if (vgdev->has_virgl_3d) {
                virtio_gpu_unref_list(&validate_list);
-                fence_put(&fence->f);
+                dma_fence_put(&fence->f);
        }
 //fail_obj:
 //      drm_gem_object_handle_unreference_unlocked(obj);
@@ -383,7 +383,7 @@ static int virtio_gpu_transfer_from_host_ioctl(struct drm_device *dev,
        reservation_object_add_excl_fence(qobj->tbo.resv,
                                          &fence->f);
-        fence_put(&fence->f);
+        dma_fence_put(&fence->f);
 out_unres:
        virtio_gpu_object_unreserve(qobj);
 out:
@@ -431,7 +431,7 @@ static int virtio_gpu_transfer_to_host_ioctl(struct drm_device *dev, void *data,
                         args->level, &box, &fence);
                reservation_object_add_excl_fence(qobj->tbo.resv,
                                                  &fence->f);
-                fence_put(&fence->f);
+                dma_fence_put(&fence->f);
        }
 out_unres:
diff --git a/drivers/gpu/drm/virtio/virtgpu_kms.c b/drivers/gpu/drm/virtio/virtgpu_kms.c
index 036b0fbae0fb..1235519853f4 100644
--- a/drivers/gpu/drm/virtio/virtgpu_kms.c
+++ b/drivers/gpu/drm/virtio/virtgpu_kms.c
@@ -159,7 +159,7 @@ int virtio_gpu_driver_load(struct drm_device *dev, unsigned long flags)
        virtio_gpu_init_vq(&vgdev->ctrlq, virtio_gpu_dequeue_ctrl_func);
        virtio_gpu_init_vq(&vgdev->cursorq, virtio_gpu_dequeue_cursor_func);
-        vgdev->fence_drv.context = fence_context_alloc(1);
+        vgdev->fence_drv.context = dma_fence_context_alloc(1);
        spin_lock_init(&vgdev->fence_drv.lock);
        INIT_LIST_HEAD(&vgdev->fence_drv.fences);
        INIT_LIST_HEAD(&vgdev->cap_cache);
diff --git a/drivers/gpu/drm/virtio/virtgpu_plane.c b/drivers/gpu/drm/virtio/virtgpu_plane.c
index ba28c0f6f28a..cb75f0663ba0 100644
--- a/drivers/gpu/drm/virtio/virtgpu_plane.c
+++ b/drivers/gpu/drm/virtio/virtgpu_plane.c
@@ -152,7 +152,7 @@ static void virtio_gpu_cursor_plane_update(struct drm_plane *plane,
                if (!ret) {
                        reservation_object_add_excl_fence(bo->tbo.resv,
                                                          &fence->f);
-                        fence_put(&fence->f);
+                        dma_fence_put(&fence->f);
                        fence = NULL;
                        virtio_gpu_object_unreserve(bo);
                        virtio_gpu_object_wait(bo, false);
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_fence.c b/drivers/gpu/drm/vmwgfx/vmwgfx_fence.c
index 26ac8e80a478..6541dd8b82dc 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_fence.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_fence.c
@@ -108,7 +108,7 @@ fman_from_fence(struct vmw_fence_obj *fence)
 * objects with actions attached to them.
 */
-static void vmw_fence_obj_destroy(struct fence *f)
+static void vmw_fence_obj_destroy(struct dma_fence *f)
 {
        struct vmw_fence_obj *fence =
                container_of(f, struct vmw_fence_obj, base);
@@ -123,17 +123,17 @@ static void vmw_fence_obj_destroy(struct fence *f)
        fence->destroy(fence);
 }
-static const char *vmw_fence_get_driver_name(struct fence *f)
+static const char *vmw_fence_get_driver_name(struct dma_fence *f)
 {
        return "vmwgfx";
 }
-static const char *vmw_fence_get_timeline_name(struct fence *f)
+static const char *vmw_fence_get_timeline_name(struct dma_fence *f)
 {
        return "svga";
 }
-static bool vmw_fence_enable_signaling(struct fence *f)
+static bool vmw_fence_enable_signaling(struct dma_fence *f)
 {
        struct vmw_fence_obj *fence =
                container_of(f, struct vmw_fence_obj, base);
@@ -152,12 +152,12 @@ static bool vmw_fence_enable_signaling(struct fence *f)
 }
 struct vmwgfx_wait_cb {
-        struct fence_cb base;
+        struct dma_fence_cb base;
        struct task_struct *task;
 };
 static void
-vmwgfx_wait_cb(struct fence *fence, struct fence_cb *cb)
+vmwgfx_wait_cb(struct dma_fence *fence, struct dma_fence_cb *cb)
 {
        struct vmwgfx_wait_cb *wait =
                container_of(cb, struct vmwgfx_wait_cb, base);
@@ -167,7 +167,7 @@ vmwgfx_wait_cb(struct fence *fence, struct fence_cb *cb)
 static void __vmw_fences_update(struct vmw_fence_manager *fman);
-static long vmw_fence_wait(struct fence *f, bool intr, signed long timeout)
+static long vmw_fence_wait(struct dma_fence *f, bool intr, signed long timeout)
 {
        struct vmw_fence_obj *fence =
                container_of(f, struct vmw_fence_obj, base);
@@ -197,7 +197,7 @@ static long vmw_fence_wait(struct fence *f, bool intr, signed long timeout)
        while (ret > 0) {
                __vmw_fences_update(fman);
-                if (test_bit(FENCE_FLAG_SIGNALED_BIT, &f->flags))
+                if (test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &f->flags))
                        break;
                if (intr)
@@ -225,7 +225,7 @@ out:
        return ret;
 }
-static struct fence_ops vmw_fence_ops = {
+static struct dma_fence_ops vmw_fence_ops = {
        .get_driver_name = vmw_fence_get_driver_name,
        .get_timeline_name = vmw_fence_get_timeline_name,
        .enable_signaling = vmw_fence_enable_signaling,
@@ -298,7 +298,7 @@ struct vmw_fence_manager *vmw_fence_manager_init(struct vmw_private *dev_priv)
        fman->event_fence_action_size =
                ttm_round_pot(sizeof(struct vmw_event_fence_action));
        mutex_init(&fman->goal_irq_mutex);
-        fman->ctx = fence_context_alloc(1);
+        fman->ctx = dma_fence_context_alloc(1);
        return fman;
 }
@@ -326,8 +326,8 @@ static int vmw_fence_obj_init(struct vmw_fence_manager *fman,
        unsigned long irq_flags;
        int ret = 0;
-        fence_init(&fence->base, &vmw_fence_ops, &fman->lock,
+        dma_fence_init(&fence->base, &vmw_fence_ops, &fman->lock,
-                   fman->ctx, seqno);
+                       fman->ctx, seqno);
        INIT_LIST_HEAD(&fence->seq_passed_actions);
        fence->destroy = destroy;
@@ -431,7 +431,7 @@ static bool vmw_fence_goal_check_locked(struct vmw_fence_obj *fence)
        u32 goal_seqno;
        u32 *fifo_mem;
-        if (fence_is_signaled_locked(&fence->base))
+        if (dma_fence_is_signaled_locked(&fence->base))
                return false;
        fifo_mem = fman->dev_priv->mmio_virt;
@@ -459,7 +459,7 @@ rerun:
        list_for_each_entry_safe(fence, next_fence, &fman->fence_list, head) {
                if (seqno - fence->base.seqno < VMW_FENCE_WRAP) {
                        list_del_init(&fence->head);
-                        fence_signal_locked(&fence->base);
+                        dma_fence_signal_locked(&fence->base);
                        INIT_LIST_HEAD(&action_list);
                        list_splice_init(&fence->seq_passed_actions,
                                         &action_list);
@@ -500,18 +500,18 @@ bool vmw_fence_obj_signaled(struct vmw_fence_obj *fence)
 {
        struct vmw_fence_manager *fman = fman_from_fence(fence);
-        if (test_bit(FENCE_FLAG_SIGNALED_BIT, &fence->base.flags))
+        if (test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->base.flags))
                return 1;
        vmw_fences_update(fman);
-        return fence_is_signaled(&fence->base);
+        return dma_fence_is_signaled(&fence->base);
 }
 int vmw_fence_obj_wait(struct vmw_fence_obj *fence, bool lazy,
                       bool interruptible, unsigned long timeout)
 {
-        long ret = fence_wait_timeout(&fence->base, interruptible, timeout);
+        long ret = dma_fence_wait_timeout(&fence->base, interruptible, timeout);
        if (likely(ret > 0))
                return 0;
@@ -530,7 +530,7 @@ void vmw_fence_obj_flush(struct vmw_fence_obj *fence)
 static void vmw_fence_destroy(struct vmw_fence_obj *fence)
 {
-        fence_free(&fence->base);
+        dma_fence_free(&fence->base);
 }
 int vmw_fence_create(struct vmw_fence_manager *fman,
@@ -669,7 +669,7 @@ void vmw_fence_fifo_down(struct vmw_fence_manager *fman)
                struct vmw_fence_obj *fence =
                        list_entry(fman->fence_list.prev, struct vmw_fence_obj,
                                   head);
-                fence_get(&fence->base);
+                dma_fence_get(&fence->base);
                spin_unlock_irq(&fman->lock);
                ret = vmw_fence_obj_wait(fence, false, false,
@@ -677,7 +677,7 @@ void vmw_fence_fifo_down(struct vmw_fence_manager *fman)
                if (unlikely(ret != 0)) {
                        list_del_init(&fence->head);
-                        fence_signal(&fence->base);
+                        dma_fence_signal(&fence->base);
                        INIT_LIST_HEAD(&action_list);
                        list_splice_init(&fence->seq_passed_actions,
                                         &action_list);
@@ -685,7 +685,7 @@ void vmw_fence_fifo_down(struct vmw_fence_manager *fman)
                }
                BUG_ON(!list_empty(&fence->head));
-                fence_put(&fence->base);
+                dma_fence_put(&fence->base);
                spin_lock_irq(&fman->lock);
        }
        spin_unlock_irq(&fman->lock);
@@ -884,7 +884,7 @@ static void vmw_fence_obj_add_action(struct vmw_fence_obj *fence,
        spin_lock_irqsave(&fman->lock, irq_flags);
        fman->pending_actions[action->type]++;
-        if (fence_is_signaled_locked(&fence->base)) {
+        if (dma_fence_is_signaled_locked(&fence->base)) {
                struct list_head action_list;
                INIT_LIST_HEAD(&action_list);
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_fence.h b/drivers/gpu/drm/vmwgfx/vmwgfx_fence.h
index 83ae301ee141..d9d85aa6ed20 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_fence.h
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_fence.h
@@ -27,7 +27,7 @@
 #ifndef _VMWGFX_FENCE_H_
-#include <linux/fence.h>
+#include <linux/dma-fence.h>
 #define VMW_FENCE_WAIT_TIMEOUT (5*HZ)
@@ -52,7 +52,7 @@ struct vmw_fence_action {
 };
 struct vmw_fence_obj {
-        struct fence base;
+        struct dma_fence base;
        struct list_head head;
        struct list_head seq_passed_actions;
@@ -71,14 +71,14 @@ vmw_fence_obj_unreference(struct vmw_fence_obj **fence_p)
        *fence_p = NULL;
        if (fence)
-                fence_put(&fence->base);
+                dma_fence_put(&fence->base);
 }
 static inline struct vmw_fence_obj *
 vmw_fence_obj_reference(struct vmw_fence_obj *fence)
 {
        if (fence)
-                fence_get(&fence->base);
+                dma_fence_get(&fence->base);
        return fence;
 }
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c b/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c
index 1a85fb2d4dc6..8e86d6d4141b 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c
@@ -1454,7 +1454,7 @@ void vmw_fence_single_bo(struct ttm_buffer_object *bo,
        if (fence == NULL) {
                vmw_execbuf_fence_commands(NULL, dev_priv, &fence, NULL);
                reservation_object_add_excl_fence(bo->resv, &fence->base);
-                fence_put(&fence->base);
+                dma_fence_put(&fence->base);
        } else
                reservation_object_add_excl_fence(bo->resv, &fence->base);
 }
author	Chris Wilson <chris@chris-wilson.co.uk>	2016-10-25 08:00:45 -0400
committer	Daniel Vetter <daniel.vetter@ffwll.ch>	2016-10-25 08:40:39 -0400
commit	f54d1867005c3323f5d8ad83eed823e84226c429 (patch)
tree	026c3f57bc546d3a0205389d0f8e0d02ce8a76ac /drivers/gpu
parent	0fc4f78f44e6c6148cee32456f0d0023ec1c1fd8 (diff)