drm/radeon: rework fence handling, drop fence list v7

Using 64bits fence sequence we can directly compare sequence
number to know if a fence is signaled or not. Thus the fence
list became useless, so does the fence lock that mainly
protected the fence list.

Things like ring.ready are no longer behind a lock, this should
be ok as ring.ready is initialized once and will only change
when facing lockup. Worst case is that we return an -EBUSY just
after a successfull GPU reset, or we go into wait state instead
of returning -EBUSY (thus delaying reporting -EBUSY to fence
wait caller).

v2: Remove left over comment, force using writeback on cayman and
    newer, thus not having to suffer from possibly scratch reg
    exhaustion
v3: Rebase on top of change to uint64 fence patch
v4: Change DCE5 test to force write back on cayman and newer but
    also any APU such as PALM or SUMO family
v5: Rebase on top of new uint64 fence patch
v6: Just break if seq doesn't change any more. Use radeon_fence
    prefix for all function names. Even if it's now highly optimized,
    try avoiding polling to often.
v7: We should never poll the last_seq from the hardware without
    waking the sleeping threads, otherwise we might lose events.

Signed-off-by: Jerome Glisse <jglisse@redhat.com>
Signed-off-by: Christian König <deathsimple@vodafone.de>
Signed-off-by: Dave Airlie <airlied@redhat.com>

3 files changed, 119 insertions, 194 deletions

diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h
index cdf46bc6dcc4..7c8711793421 100644
--- a/drivers/gpu/drm/radeon/radeon.h
+++ b/drivers/gpu/drm/radeon/radeon.h
@@ -263,15 +263,12 @@ struct radeon_fence_driver {
         atomic64_t                      last_seq;
         unsigned long                   last_activity;
         wait_queue_head_t               queue;
-        struct list_head                emitted;
-        struct list_head                signaled;
         bool                            initialized;
 };
 
 struct radeon_fence {
         struct radeon_device            *rdev;
         struct kref                     kref;
-        struct list_head                list;
         /* protected by radeon_fence.lock */
         uint64_t                        seq;
         /* RB, DMA, etc. */
@@ -291,7 +288,7 @@ int radeon_fence_wait_next(struct radeon_device *rdev, int ring);
 int radeon_fence_wait_empty(struct radeon_device *rdev, int ring);
 struct radeon_fence *radeon_fence_ref(struct radeon_fence *fence);
 void radeon_fence_unref(struct radeon_fence **fence);
-int radeon_fence_count_emitted(struct radeon_device *rdev, int ring);
+unsigned radeon_fence_count_emitted(struct radeon_device *rdev, int ring);
 
 /*
  * Tiling registers
@@ -1534,7 +1531,6 @@ struct radeon_device {
         struct radeon_mode_info         mode_info;
         struct radeon_scratch           scratch;
         struct radeon_mman              mman;
-        rwlock_t                        fence_lock;
         struct radeon_fence_driver      fence_drv[RADEON_NUM_RINGS];
         struct radeon_semaphore_driver  semaphore_drv;
         struct mutex                    ring_lock;
diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c
index 3f6ff2a0bce2..0e7b72a0ed35 100644
--- a/drivers/gpu/drm/radeon/radeon_device.c
+++ b/drivers/gpu/drm/radeon/radeon_device.c
@@ -225,9 +225,9 @@ int radeon_wb_init(struct radeon_device *rdev)
         /* disable event_write fences */
         rdev->wb.use_event = false;
         /* disabled via module param */
-        if (radeon_no_wb == 1)
+        if (radeon_no_wb == 1) {
                 rdev->wb.enabled = false;
-        else {
+        } else {
                 if (rdev->flags & RADEON_IS_AGP) {
                         /* often unreliable on AGP */
                         rdev->wb.enabled = false;
@@ -237,8 +237,9 @@ int radeon_wb_init(struct radeon_device *rdev)
                 } else {
                         rdev->wb.enabled = true;
                         /* event_write fences are only available on r600+ */
-                        if (rdev->family >= CHIP_R600)
+                        if (rdev->family >= CHIP_R600) {
                                 rdev->wb.use_event = true;
+                        }
                 }
         }
         /* always use writeback/events on NI, APUs */
@@ -731,7 +732,6 @@ int radeon_device_init(struct radeon_device *rdev,
         mutex_init(&rdev->gem.mutex);
         mutex_init(&rdev->pm.mutex);
         mutex_init(&rdev->vram_mutex);
-        rwlock_init(&rdev->fence_lock);
         rwlock_init(&rdev->semaphore_drv.lock);
         INIT_LIST_HEAD(&rdev->gem.objects);
         init_waitqueue_head(&rdev->irq.vblank_queue);
diff --git a/drivers/gpu/drm/radeon/radeon_fence.c b/drivers/gpu/drm/radeon/radeon_fence.c
index feb2bbc6ef6d..ed202255ac76 100644
--- a/drivers/gpu/drm/radeon/radeon_fence.c
+++ b/drivers/gpu/drm/radeon/radeon_fence.c
@@ -63,30 +63,18 @@ static u32 radeon_fence_read(struct radeon_device *rdev, int ring)
 
 int radeon_fence_emit(struct radeon_device *rdev, struct radeon_fence *fence)
 {
-        unsigned long irq_flags;
-
-        write_lock_irqsave(&rdev->fence_lock, irq_flags);
+        /* we are protected by the ring emission mutex */
         if (fence->seq && fence->seq < RADEON_FENCE_NOTEMITED_SEQ) {
-                write_unlock_irqrestore(&rdev->fence_lock, irq_flags);
                 return 0;
         }
-        /* we are protected by the ring emission mutex */
         fence->seq = ++rdev->fence_drv[fence->ring].seq;
         radeon_fence_ring_emit(rdev, fence->ring, fence);
         trace_radeon_fence_emit(rdev->ddev, fence->seq);
-        /* are we the first fence on a previusly idle ring? */
-        if (list_empty(&rdev->fence_drv[fence->ring].emitted)) {
-                rdev->fence_drv[fence->ring].last_activity = jiffies;
-        }
-        list_move_tail(&fence->list, &rdev->fence_drv[fence->ring].emitted);
-        write_unlock_irqrestore(&rdev->fence_lock, irq_flags);
         return 0;
 }
 
-static bool radeon_fence_poll_locked(struct radeon_device *rdev, int ring)
+void radeon_fence_process(struct radeon_device *rdev, int ring)
 {
-        struct radeon_fence *fence;
-        struct list_head *i, *n;
         uint64_t seq, last_seq;
         unsigned count_loop = 0;
         bool wake = false;
@@ -120,14 +108,15 @@ static bool radeon_fence_poll_locked(struct radeon_device *rdev, int ring)
                         seq += 0x100000000LL;
                 }
 
-                if (!wake && seq == last_seq) {
-                        return false;
+                if (seq == last_seq) {
+                        break;
                 }
                 /* If we loop over we don't want to return without
                  * checking if a fence is signaled as it means that the
                  * seq we just read is different from the previous on.
                  */
                 wake = true;
+                last_seq = seq;
                 if ((count_loop++) > 10) {
                         /* We looped over too many time leave with the
                          * fact that we might have set an older fence
@@ -136,46 +125,20 @@ static bool radeon_fence_poll_locked(struct radeon_device *rdev, int ring)
                          */
                         break;
                 }
-                last_seq = seq;
         } while (atomic64_xchg(&rdev->fence_drv[ring].last_seq, seq) > seq);
 
-        /* reset wake to false */
-        wake = false;
-        rdev->fence_drv[ring].last_activity = jiffies;
-
-        n = NULL;
-        list_for_each(i, &rdev->fence_drv[ring].emitted) {
-                fence = list_entry(i, struct radeon_fence, list);
-                if (fence->seq == seq) {
-                        n = i;
+        if (wake) {
+                rdev->fence_drv[ring].last_activity = jiffies;
+                wake_up_all(&rdev->fence_drv[ring].queue);