Merge branch 'drm-next-4.20' of git://people.freedesktop.org/~agd5f/linux into drm-next

Fixes for 4.20.  Highlights:
- VCN DPG fixes for Picasso
- Add support for the latest vega20 vbios
- Scheduler timeout fix
- License fixes for radeon and amdgpu
- Misc other fixes

Signed-off-by: Dave Airlie <airlied@redhat.com>
From: Alex Deucher <alexdeucher@gmail.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20181017215427.2804-1-alexander.deucher@amd.com

1 files changed, 46 insertions, 13 deletions

diff --git a/drivers/gpu/drm/scheduler/sched_main.c b/drivers/gpu/drm/scheduler/sched_main.c
index 4e8505d51795..44fe587aaef9 100644
--- a/drivers/gpu/drm/scheduler/sched_main.c
+++ b/drivers/gpu/drm/scheduler/sched_main.c
@@ -182,6 +182,20 @@ bool drm_sched_dependency_optimized(struct dma_fence* fence,
 }
 EXPORT_SYMBOL(drm_sched_dependency_optimized);
 
+/**
+ * drm_sched_start_timeout - start timeout for reset worker
+ *
+ * @sched: scheduler instance to start the worker for
+ *
+ * Start the timeout for the given scheduler.
+ */
+static void drm_sched_start_timeout(struct drm_gpu_scheduler *sched)
+{
+        if (sched->timeout != MAX_SCHEDULE_TIMEOUT &&
+            !list_empty(&sched->ring_mirror_list))
+                schedule_delayed_work(&sched->work_tdr, sched->timeout);
+}
+
 /* job_finish is called after hw fence signaled
  */
 static void drm_sched_job_finish(struct work_struct *work)
@@ -203,9 +217,7 @@ static void drm_sched_job_finish(struct work_struct *work)
         /* remove job from ring_mirror_list */
         list_del(&s_job->node);
         /* queue TDR for next job */
-        if (sched->timeout != MAX_SCHEDULE_TIMEOUT &&
-            !list_empty(&sched->ring_mirror_list))
-                schedule_delayed_work(&sched->work_tdr, sched->timeout);
+        drm_sched_start_timeout(sched);
         spin_unlock(&sched->job_list_lock);
 
         dma_fence_put(&s_job->s_fence->finished);
@@ -229,10 +241,7 @@ static void drm_sched_job_begin(struct drm_sched_job *s_job)
 
         spin_lock(&sched->job_list_lock);
         list_add_tail(&s_job->node, &sched->ring_mirror_list);
-        if (sched->timeout != MAX_SCHEDULE_TIMEOUT &&
-            list_first_entry_or_null(&sched->ring_mirror_list,
-                                     struct drm_sched_job, node) == s_job)
-                schedule_delayed_work(&sched->work_tdr, sched->timeout);
+        drm_sched_start_timeout(sched);
         spin_unlock(&sched->job_list_lock);
 }
 
@@ -240,13 +249,41 @@ static void drm_sched_job_timedout(struct work_struct *work)
 {
         struct drm_gpu_scheduler *sched;
         struct drm_sched_job *job;
+        int r;
 
         sched = container_of(work, struct drm_gpu_scheduler, work_tdr.work);
+
+        spin_lock(&sched->job_list_lock);
+        list_for_each_entry_reverse(job, &sched->ring_mirror_list, node) {
+                struct drm_sched_fence *fence = job->s_fence;
+
+                if (!dma_fence_remove_callback(fence->parent, &fence->cb))
+                        goto already_signaled;
+        }
+
         job = list_first_entry_or_null(&sched->ring_mirror_list,
                                        struct drm_sched_job, node);
+        spin_unlock(&sched->job_list_lock);
 
         if (job)
-                job->sched->ops->timedout_job(job);
+                sched->ops->timedout_job(job);
+
+        spin_lock(&sched->job_list_lock);
+        list_for_each_entry(job, &sched->ring_mirror_list, node) {
+                struct drm_sched_fence *fence = job->s_fence;
+
+                if (!fence->parent || !list_empty(&fence->cb.node))
+                        continue;
+
+                r = dma_fence_add_callback(fence->parent, &fence->cb,
+                                           drm_sched_process_job);
+                if (r)
+                        drm_sched_process_job(fence->parent, &fence->cb);
+
+already_signaled:
+                ;
+        }
+        spin_unlock(&sched->job_list_lock);
 }
 
 /**
@@ -313,11 +350,6 @@ void drm_sched_job_recovery(struct drm_gpu_scheduler *sched)
         int r;
 
         spin_lock(&sched->job_list_lock);
-        s_job = list_first_entry_or_null(&sched->ring_mirror_list,
-                                         struct drm_sched_job, node);
-        if (s_job && sched->timeout != MAX_SCHEDULE_TIMEOUT)
-                schedule_delayed_work(&sched->work_tdr, sched->timeout);
-
         list_for_each_entry_safe(s_job, tmp, &sched->ring_mirror_list, node) {
                 struct drm_sched_fence *s_fence = s_job->s_fence;
                 struct dma_fence *fence;
@@ -350,6 +382,7 @@ void drm_sched_job_recovery(struct drm_gpu_scheduler *sched)
                 }
                 spin_lock(&sched->job_list_lock);
         }
+        drm_sched_start_timeout(sched);
         spin_unlock(&sched->job_list_lock);
 }
 EXPORT_SYMBOL(drm_sched_job_recovery);