Merge tag 'fbdev-4.3' of git://git.kernel.org/pub/scm/linux/kernel/git/tomba/linux

[linux.git] / drivers / gpu / drm / amd / amdgpu / amdgpu_test.c

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_test.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_test.c
index df202999fbfe7c54f5c96b39dea8dc856c0f185a..f80b1a43be8a549aaec7febbcf5df8f2ec3de702 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_test.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_test.c
@@ -77,7 +77,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 amdgpu_fence *fence = NULL;
+               struct fence *fence = NULL;
 
                r = amdgpu_bo_create(adev, size, PAGE_SIZE, true,
                                     AMDGPU_GEM_DOMAIN_GTT, 0, NULL, gtt_obj + i);
@@ -116,13 +116,13 @@ static void amdgpu_do_test_moves(struct amdgpu_device *adev)
                        goto out_lclean_unpin;
                }
 
-               r = amdgpu_fence_wait(fence, false);
+               r = fence_wait(fence, false);
                if (r) {
                        DRM_ERROR("Failed to wait for GTT->VRAM fence %d\n", i);
                        goto out_lclean_unpin;
                }
 
-               amdgpu_fence_unref(&fence);
+               fence_put(fence);
 
                r = amdgpu_bo_kmap(vram_obj, &vram_map);
                if (r) {
@@ -161,13 +161,13 @@ static void amdgpu_do_test_moves(struct amdgpu_device *adev)
                        goto out_lclean_unpin;
                }
 
-               r = amdgpu_fence_wait(fence, false);
+               r = fence_wait(fence, false);
                if (r) {
                        DRM_ERROR("Failed to wait for VRAM->GTT fence %d\n", i);
                        goto out_lclean_unpin;
                }
 
-               amdgpu_fence_unref(&fence);
+               fence_put(fence);
 
                r = amdgpu_bo_kmap(gtt_obj[i], &gtt_map);
                if (r) {
@@ -214,7 +214,7 @@ out_lclean:
                        amdgpu_bo_unref(&gtt_obj[i]);
                }
                if (fence)
-                       amdgpu_fence_unref(&fence);
+                       fence_put(fence);
                break;
        }
 
@@ -238,7 +238,7 @@ void amdgpu_test_moves(struct amdgpu_device *adev)
 
 static int amdgpu_test_create_and_emit_fence(struct amdgpu_device *adev,
                                             struct amdgpu_ring *ring,
-                                            struct amdgpu_fence **fence)
+                                            struct fence **fence)
 {
        uint32_t handle = ring->idx ^ 0xdeafbeef;
        int r;
@@ -269,15 +269,16 @@ static int amdgpu_test_create_and_emit_fence(struct amdgpu_device *adev,
                        DRM_ERROR("Failed to get dummy destroy msg\n");
                        return r;
                }
-
        } else {
+               struct amdgpu_fence *a_fence = NULL;
                r = amdgpu_ring_lock(ring, 64);
                if (r) {
                        DRM_ERROR("Failed to lock ring A %d\n", ring->idx);
                        return r;
                }
-               amdgpu_fence_emit(ring, AMDGPU_FENCE_OWNER_UNDEFINED, fence);
+               amdgpu_fence_emit(ring, AMDGPU_FENCE_OWNER_UNDEFINED, &a_fence);
                amdgpu_ring_unlock_commit(ring);
+               *fence = &a_fence->base;
        }
        return 0;
 }
@@ -286,7 +287,7 @@ void amdgpu_test_ring_sync(struct amdgpu_device *adev,
                           struct amdgpu_ring *ringA,
                           struct amdgpu_ring *ringB)
 {
-       struct amdgpu_fence *fence1 = NULL, *fence2 = NULL;
+       struct fence *fence1 = NULL, *fence2 = NULL;
        struct amdgpu_semaphore *semaphore = NULL;
        int r;
 
@@ -322,7 +323,7 @@ void amdgpu_test_ring_sync(struct amdgpu_device *adev,
 
        mdelay(1000);
 
-       if (amdgpu_fence_signaled(fence1)) {
+       if (fence_is_signaled(fence1)) {
                DRM_ERROR("Fence 1 signaled without waiting for semaphore.\n");
                goto out_cleanup;
        }
@@ -335,7 +336,7 @@ void amdgpu_test_ring_sync(struct amdgpu_device *adev,
        amdgpu_semaphore_emit_signal(ringB, semaphore);
        amdgpu_ring_unlock_commit(ringB);
 
-       r = amdgpu_fence_wait(fence1, false);
+       r = fence_wait(fence1, false);
        if (r) {
                DRM_ERROR("Failed to wait for sync fence 1\n");
                goto out_cleanup;
@@ -343,7 +344,7 @@ void amdgpu_test_ring_sync(struct amdgpu_device *adev,
 
        mdelay(1000);
 
-       if (amdgpu_fence_signaled(fence2)) {
+       if (fence_is_signaled(fence2)) {
                DRM_ERROR("Fence 2 signaled without waiting for semaphore.\n");
                goto out_cleanup;
        }
@@ -356,7 +357,7 @@ void amdgpu_test_ring_sync(struct amdgpu_device *adev,
        amdgpu_semaphore_emit_signal(ringB, semaphore);
        amdgpu_ring_unlock_commit(ringB);
 
-       r = amdgpu_fence_wait(fence2, false);
+       r = fence_wait(fence2, false);
        if (r) {
                DRM_ERROR("Failed to wait for sync fence 1\n");
                goto out_cleanup;
@@ -366,10 +367,10 @@ out_cleanup:
        amdgpu_semaphore_free(adev, &semaphore, NULL);
 
        if (fence1)
-               amdgpu_fence_unref(&fence1);
+               fence_put(fence1);
 
        if (fence2)
-               amdgpu_fence_unref(&fence2);
+               fence_put(fence2);
 
        if (r)
                printk(KERN_WARNING "Error while testing ring sync (%d).\n", r);
@@ -380,7 +381,7 @@ static void amdgpu_test_ring_sync2(struct amdgpu_device *adev,
                            struct amdgpu_ring *ringB,
                            struct amdgpu_ring *ringC)
 {
-       struct amdgpu_fence *fenceA = NULL, *fenceB = NULL;
+       struct fence *fenceA = NULL, *fenceB = NULL;
        struct amdgpu_semaphore *semaphore = NULL;
        bool sigA, sigB;
        int i, r;
@@ -416,11 +417,11 @@ static void amdgpu_test_ring_sync2(struct amdgpu_device *adev,
 
        mdelay(1000);
 
-       if (amdgpu_fence_signaled(fenceA)) {
+       if (fence_is_signaled(fenceA)) {
                DRM_ERROR("Fence A signaled without waiting for semaphore.\n");
                goto out_cleanup;
        }
-       if (amdgpu_fence_signaled(fenceB)) {
+       if (fence_is_signaled(fenceB)) {
                DRM_ERROR("Fence B signaled without waiting for semaphore.\n");
                goto out_cleanup;
        }
@@ -435,8 +436,8 @@ static void amdgpu_test_ring_sync2(struct amdgpu_device *adev,
 
        for (i = 0; i < 30; ++i) {
                mdelay(100);
-               sigA = amdgpu_fence_signaled(fenceA);
-               sigB = amdgpu_fence_signaled(fenceB);
+               sigA = fence_is_signaled(fenceA);
+               sigB = fence_is_signaled(fenceB);
                if (sigA || sigB)
                        break;
        }
@@ -461,12 +462,12 @@ static void amdgpu_test_ring_sync2(struct amdgpu_device *adev,
 
        mdelay(1000);
 
-       r = amdgpu_fence_wait(fenceA, false);
+       r = fence_wait(fenceA, false);
        if (r) {
                DRM_ERROR("Failed to wait for sync fence A\n");
                goto out_cleanup;
        }
-       r = amdgpu_fence_wait(fenceB, false);
+       r = fence_wait(fenceB, false);
        if (r) {
                DRM_ERROR("Failed to wait for sync fence B\n");
                goto out_cleanup;
@@ -476,10 +477,10 @@ out_cleanup:
        amdgpu_semaphore_free(adev, &semaphore, NULL);
 
        if (fenceA)
-               amdgpu_fence_unref(&fenceA);
+               fence_put(fenceA);
 
        if (fenceB)
-               amdgpu_fence_unref(&fenceB);
+               fence_put(fenceB);
 
        if (r)
                printk(KERN_WARNING "Error while testing ring sync (%d).\n", r);