Revert "drm/ttm: add a way to bo_wait for either the last read or last write"

[deliverable/linux.git] / drivers / gpu / drm / ttm / ttm_bo.c

diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c
index 50fc8e4c9a310c78b57ca4e749bc46eb1ea0a4f0..617b64678fc62f24c70df6ae3fd7ba3bc7d6c9bf 100644 (file)
--- a/drivers/gpu/drm/ttm/ttm_bo.c
+++ b/drivers/gpu/drm/ttm/ttm_bo.c
@@ -499,7 +499,7 @@ static void ttm_bo_cleanup_refs_or_queue(struct ttm_buffer_object *bo)
        int ret;
 
        spin_lock(&bdev->fence_lock);
-       (void) ttm_bo_wait(bo, false, false, true, TTM_USAGE_READWRITE);
+       (void) ttm_bo_wait(bo, false, false, true);
        if (!bo->sync_obj) {
 
                spin_lock(&glob->lru_lock);
@@ -567,8 +567,7 @@ static int ttm_bo_cleanup_refs(struct ttm_buffer_object *bo,
 
 retry:
        spin_lock(&bdev->fence_lock);
-       ret = ttm_bo_wait(bo, false, interruptible, no_wait_gpu,
-                         TTM_USAGE_READWRITE);
+       ret = ttm_bo_wait(bo, false, interruptible, no_wait_gpu);
        spin_unlock(&bdev->fence_lock);
 
        if (unlikely(ret != 0))
@@ -727,8 +726,7 @@ static int ttm_bo_evict(struct ttm_buffer_object *bo, bool interruptible,
        int ret = 0;
 
        spin_lock(&bdev->fence_lock);
-       ret = ttm_bo_wait(bo, false, interruptible, no_wait_gpu,
-                         TTM_USAGE_READWRITE);
+       ret = ttm_bo_wait(bo, false, interruptible, no_wait_gpu);
        spin_unlock(&bdev->fence_lock);
 
        if (unlikely(ret != 0)) {
@@ -1075,8 +1073,7 @@ int ttm_bo_move_buffer(struct ttm_buffer_object *bo,
         * instead of doing it here.
         */
        spin_lock(&bdev->fence_lock);
-       ret = ttm_bo_wait(bo, false, interruptible, no_wait_gpu,
-                         TTM_USAGE_READWRITE);
+       ret = ttm_bo_wait(bo, false, interruptible, no_wait_gpu);
        spin_unlock(&bdev->fence_lock);
        if (ret)
                return ret;
@@ -1697,83 +1694,34 @@ out_unlock:
        return ret;
 }
 
-static void ttm_bo_unref_sync_obj_locked(struct ttm_buffer_object *bo,
-                                        void *sync_obj,
-                                        void **extra_sync_obj)
-{
-       struct ttm_bo_device *bdev = bo->bdev;
-       struct ttm_bo_driver *driver = bdev->driver;
-       void *tmp_obj = NULL, *tmp_obj_read = NULL, *tmp_obj_write = NULL;
-
-       /* We must unref the sync obj wherever it's ref'd.
-        * Note that if we unref bo->sync_obj, we can unref both the read
-        * and write sync objs too, because they can't be newer than
-        * bo->sync_obj, so they are no longer relevant. */
-       if (sync_obj == bo->sync_obj ||
-           sync_obj == bo->sync_obj_read) {
-               tmp_obj_read = bo->sync_obj_read;
-               bo->sync_obj_read = NULL;
-       }
-       if (sync_obj == bo->sync_obj ||
-           sync_obj == bo->sync_obj_write) {
-               tmp_obj_write = bo->sync_obj_write;
-               bo->sync_obj_write = NULL;
-       }
-       if (sync_obj == bo->sync_obj) {
-               tmp_obj = bo->sync_obj;
-               bo->sync_obj = NULL;
-       }
-
-       clear_bit(TTM_BO_PRIV_FLAG_MOVING, &bo->priv_flags);
-       spin_unlock(&bdev->fence_lock);
-       if (tmp_obj)
-               driver->sync_obj_unref(&tmp_obj);
-       if (tmp_obj_read)
-               driver->sync_obj_unref(&tmp_obj_read);
-       if (tmp_obj_write)
-               driver->sync_obj_unref(&tmp_obj_write);
-       if (extra_sync_obj)
-               driver->sync_obj_unref(extra_sync_obj);
-       spin_lock(&bdev->fence_lock);
-}
-
 int ttm_bo_wait(struct ttm_buffer_object *bo,
-               bool lazy, bool interruptible, bool no_wait,
-               enum ttm_buffer_usage usage)
+               bool lazy, bool interruptible, bool no_wait)
 {
        struct ttm_bo_driver *driver = bo->bdev->driver;
        struct ttm_bo_device *bdev = bo->bdev;
        void *sync_obj;
        void *sync_obj_arg;
        int ret = 0;
-       void **bo_sync_obj;
 
-       switch (usage) {
-       case TTM_USAGE_READ:
-               bo_sync_obj = &bo->sync_obj_read;
-               break;
-       case TTM_USAGE_WRITE:
-               bo_sync_obj = &bo->sync_obj_write;
-               break;
-       case TTM_USAGE_READWRITE:
-       default:
-               bo_sync_obj = &bo->sync_obj;
-       }
-
-       if (likely(*bo_sync_obj == NULL))
+       if (likely(bo->sync_obj == NULL))
                return 0;
 
-       while (*bo_sync_obj) {
+       while (bo->sync_obj) {
 
-               if (driver->sync_obj_signaled(*bo_sync_obj, bo->sync_obj_arg)) {
-                       ttm_bo_unref_sync_obj_locked(bo, *bo_sync_obj, NULL);
+               if (driver->sync_obj_signaled(bo->sync_obj, bo->sync_obj_arg)) {
+                       void *tmp_obj = bo->sync_obj;
+                       bo->sync_obj = NULL;
+                       clear_bit(TTM_BO_PRIV_FLAG_MOVING, &bo->priv_flags);
+                       spin_unlock(&bdev->fence_lock);
+                       driver->sync_obj_unref(&tmp_obj);
+                       spin_lock(&bdev->fence_lock);
                        continue;
                }
 
                if (no_wait)
                        return -EBUSY;
 
-               sync_obj = driver->sync_obj_ref(*bo_sync_obj);
+               sync_obj = driver->sync_obj_ref(bo->sync_obj);
                sync_obj_arg = bo->sync_obj_arg;
                spin_unlock(&bdev->fence_lock);
                ret = driver->sync_obj_wait(sync_obj, sync_obj_arg,
@@ -1784,9 +1732,16 @@ int ttm_bo_wait(struct ttm_buffer_object *bo,
                        return ret;
                }
                spin_lock(&bdev->fence_lock);
-               if (likely(*bo_sync_obj == sync_obj &&
+               if (likely(bo->sync_obj == sync_obj &&
                           bo->sync_obj_arg == sync_obj_arg)) {
-                       ttm_bo_unref_sync_obj_locked(bo, *bo_sync_obj, &sync_obj);
+                       void *tmp_obj = bo->sync_obj;
+                       bo->sync_obj = NULL;
+                       clear_bit(TTM_BO_PRIV_FLAG_MOVING,
+                                 &bo->priv_flags);
+                       spin_unlock(&bdev->fence_lock);
+                       driver->sync_obj_unref(&sync_obj);
+                       driver->sync_obj_unref(&tmp_obj);
+                       spin_lock(&bdev->fence_lock);
                } else {
                        spin_unlock(&bdev->fence_lock);
                        driver->sync_obj_unref(&sync_obj);
@@ -1810,7 +1765,7 @@ int ttm_bo_synccpu_write_grab(struct ttm_buffer_object *bo, bool no_wait)
        if (unlikely(ret != 0))
                return ret;
        spin_lock(&bdev->fence_lock);
-       ret = ttm_bo_wait(bo, false, true, no_wait, TTM_USAGE_READWRITE);
+       ret = ttm_bo_wait(bo, false, true, no_wait);
        spin_unlock(&bdev->fence_lock);
        if (likely(ret == 0))
                atomic_inc(&bo->cpu_writers);
@@ -1884,7 +1839,7 @@ static int ttm_bo_swapout(struct ttm_mem_shrink *shrink)
         */
 
        spin_lock(&bo->bdev->fence_lock);
-       ret = ttm_bo_wait(bo, false, false, false, TTM_USAGE_READWRITE);
+       ret = ttm_bo_wait(bo, false, false, false);
        spin_unlock(&bo->bdev->fence_lock);
 
        if (unlikely(ret != 0))