drm/amdgpu: more scheduler cleanups v2

Embed the scheduler into the ring structure instead of allocating it.
Use the ring name directly instead of the id.

v2: rebased, whitespace cleanup

Signed-off-by: Christian König <christian.koenig@amd.com>
Reviewed-by: Junwei Zhang <Jerry.Zhang@amd.com>
Reviewed-by: Chunming Zhou<david1.zhou@amd.com>

8 files changed, 61 insertions, 37 deletions

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu.h b/drivers/gpu/drm/amd/amdgpu/amdgpu.h
index 9108b7c7d4a3..57b427f958da 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu.h
@@ -433,7 +433,7 @@ int amdgpu_fence_driver_init(struct amdgpu_device *adev);
 void amdgpu_fence_driver_fini(struct amdgpu_device *adev);
 void amdgpu_fence_driver_force_completion(struct amdgpu_device *adev);
 
-void amdgpu_fence_driver_init_ring(struct amdgpu_ring *ring);
+int amdgpu_fence_driver_init_ring(struct amdgpu_ring *ring);
 int amdgpu_fence_driver_start_ring(struct amdgpu_ring *ring,
                                    struct amdgpu_irq_src *irq_src,
                                    unsigned irq_type);
@@ -891,7 +891,7 @@ struct amdgpu_ring {
         struct amdgpu_device            *adev;
         const struct amdgpu_ring_funcs  *funcs;
         struct amdgpu_fence_driver      fence_drv;
-        struct amd_gpu_scheduler        *sched;
+        struct amd_gpu_scheduler        sched;
 
         spinlock_t              fence_lock;
         struct mutex            *ring_lock;
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
index 6f39b2d2106d..b74b6a8e80a6 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
@@ -848,7 +848,7 @@ int amdgpu_cs_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
                 job = kzalloc(sizeof(struct amdgpu_job), GFP_KERNEL);
                 if (!job)
                         return -ENOMEM;
-                job->base.sched = ring->sched;
+                job->base.sched = &ring->sched;
                 job->base.s_entity = &parser->ctx->rings[ring->idx].entity;
                 job->adev = parser->adev;
                 job->ibs = parser->ibs;
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ctx.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ctx.c
index 5494831e1a24..e0b80ccdfe8a 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ctx.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ctx.c
@@ -43,10 +43,10 @@ int amdgpu_ctx_init(struct amdgpu_device *adev, bool kernel,
                 for (i = 0; i < adev->num_rings; i++) {
                         struct amd_sched_rq *rq;
                         if (kernel)
-                                rq = &adev->rings[i]->sched->kernel_rq;
+                                rq = &adev->rings[i]->sched.kernel_rq;
                         else
-                                rq = &adev->rings[i]->sched->sched_rq;
-                        r = amd_sched_entity_init(adev->rings[i]->sched,
+                                rq = &adev->rings[i]->sched.sched_rq;
+                        r = amd_sched_entity_init(&adev->rings[i]->sched,
                                                   &ctx->rings[i].entity,
                                                   rq, amdgpu_sched_jobs);
                         if (r)
@@ -55,7 +55,7 @@ int amdgpu_ctx_init(struct amdgpu_device *adev, bool kernel,
 
                 if (i < adev->num_rings) {
                         for (j = 0; j < i; j++)
-                                amd_sched_entity_fini(adev->rings[j]->sched,
+                                amd_sched_entity_fini(&adev->rings[j]->sched,
                                                       &ctx->rings[j].entity);
                         kfree(ctx);
                         return r;
@@ -75,7 +75,7 @@ void amdgpu_ctx_fini(struct amdgpu_ctx *ctx)
 
         if (amdgpu_enable_scheduler) {
                 for (i = 0; i < adev->num_rings; i++)
-                        amd_sched_entity_fini(adev->rings[i]->sched,
+                        amd_sched_entity_fini(&adev->rings[i]->sched,
                                               &ctx->rings[i].entity);
         }
 }
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c
index 7f2d85e7e77a..b3fc26c59787 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c
@@ -609,9 +609,9 @@ int amdgpu_fence_driver_start_ring(struct amdgpu_ring *ring,
  * Init the fence driver for the requested ring (all asics).
  * Helper function for amdgpu_fence_driver_init().
  */
-void amdgpu_fence_driver_init_ring(struct amdgpu_ring *ring)
+int amdgpu_fence_driver_init_ring(struct amdgpu_ring *ring)
 {
-        int i;
+        int i, r;
 
         ring->fence_drv.cpu_addr = NULL;
         ring->fence_drv.gpu_addr = 0;
@@ -628,14 +628,16 @@ void amdgpu_fence_driver_init_ring(struct amdgpu_ring *ring)
         init_waitqueue_head(&ring->fence_drv.fence_queue);
 
         if (amdgpu_enable_scheduler) {
-                ring->sched = amd_sched_create(&amdgpu_sched_ops,
-                                               ring->idx,
-                                               amdgpu_sched_hw_submission,
-                                               (void *)ring->adev);
-                if (!ring->sched)
-                        DRM_ERROR("Failed to create scheduler on ring %d.\n",
-                                  ring->idx);
+                r = amd_sched_init(&ring->sched, &amdgpu_sched_ops,
+                                   amdgpu_sched_hw_submission, ring->name);
+                if (r) {
+                        DRM_ERROR("Failed to create scheduler on ring %s.\n",
+                                  ring->name);
+                        return r;
+                }
         }
+
+        return 0;
 }
 
 /**
@@ -683,8 +685,7 @@ void amdgpu_fence_driver_fini(struct amdgpu_device *adev)
                 wake_up_all(&ring->fence_drv.fence_queue);
                 amdgpu_irq_put(adev, ring->fence_drv.irq_src,
                                ring->fence_drv.irq_type);
-                if (ring->sched)
-                        amd_sched_destroy(ring->sched);
+                amd_sched_fini(&ring->sched);
                 ring->fence_drv.initialized = false;
         }
         mutex_unlock(&adev->ring_lock);
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c
index 6e735431676d..30dce235ddeb 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c
@@ -357,7 +357,9 @@ int amdgpu_ring_init(struct amdgpu_device *adev, struct amdgpu_ring *ring,
                 ring->adev = adev;
                 ring->idx = adev->num_rings++;
                 adev->rings[ring->idx] = ring;
-                amdgpu_fence_driver_init_ring(ring);
+                r = amdgpu_fence_driver_init_ring(ring);
+                if (r)
+                        return r;
         }
 
         r = amdgpu_wb_get(adev, &ring->rptr_offs);
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_sa.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_sa.c
index 7cf5405afe4e..e90712443fe9 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_sa.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_sa.c
@@ -145,8 +145,13 @@ static uint32_t amdgpu_sa_get_ring_from_fence(struct fence *f)
         struct amd_sched_fence *s_fence;
 
         s_fence = to_amd_sched_fence(f);
-        if (s_fence)
-                return s_fence->sched->ring_id;
+        if (s_fence) {
+                struct amdgpu_ring *ring;
+
+                ring = container_of(s_fence->sched, struct amdgpu_ring, sched);
+                return ring->idx;
+        }
+
         a_fence = to_amdgpu_fence(f);
         if (a_fence)
                 return a_fence->ring->idx;
@@ -412,6 +417,26 @@ void amdgpu_sa_bo_free(struct amdgpu_device *adev, struct amdgpu_sa_bo **sa_bo,
 }
 
 #if defined(CONFIG_DEBUG_FS)
+
+static void amdgpu_sa_bo_dump_fence(struct fence *fence, struct seq_file *m)
+{
+        struct amdgpu_fence *a_fence = to_amdgpu_fence(fence);
+        struct amd_sched_fence *s_fence = to_amd_sched_fence(fence);
+
+        if (a_fence)
+                seq_printf(m, " protected by 0x%016llx on ring %d",
+                           a_fence->seq, a_fence->ring->idx);
+
+        if (s_fence) {
+                struct amdgpu_ring *ring;
+
+
+                ring = container_of(s_fence->sched, struct amdgpu_ring, sched);
+                seq_printf(m, " protected by 0x%016x on ring %d",
+                           s_fence->base.seqno, ring->idx);
+        }
+}
+
 void amdgpu_sa_bo_dump_debug_info(struct amdgpu_sa_manager *sa_manager,
                                   struct seq_file *m)
 {
@@ -428,18 +453,8 @@ void amdgpu_sa_bo_dump_debug_info(struct amdgpu_sa_manager *sa_manager,
                 }
                 seq_printf(m, "[0x%010llx 0x%010llx] size %8lld",
                            soffset, eoffset, eoffset - soffset);
-                if (i->fence) {
-                        struct amdgpu_fence *a_fence = to_amdgpu_fence(i->fence);
-                        struct amd_sched_fence *s_fence = to_amd_sched_fence(i->fence);
-                        if (a_fence)
-                                seq_printf(m, " protected by 0x%016llx on ring %d",
-                                           a_fence->seq, a_fence->ring->idx);
-                        if (s_fence)
-                                seq_printf(m, " protected by 0x%016x on ring %d",
-                                           s_fence->base.seqno,
-                                           s_fence->sched->ring_id);
-
-                }
+                if (i->fence)
+                        amdgpu_sa_bo_dump_fence(i->fence, m);
                 seq_printf(m, "\n");
         }
         spin_unlock(&sa_manager->wq.lock);
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_sched.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_sched.c
index d1984fc5dfc4..2e946b2cad88 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_sched.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_sched.c
@@ -85,7 +85,7 @@ int amdgpu_sched_ib_submit_kernel_helper(struct amdgpu_device *adev,
                         kzalloc(sizeof(struct amdgpu_job), GFP_KERNEL);
                 if (!job)
                         return -ENOMEM;
-                job->base.sched = ring->sched;
+                job->base.sched = &ring->sched;
                 job->base.s_entity = &adev->kernel_ctx.rings[ring->idx].entity;
                 job->adev = adev;
                 job->ibs = ibs;
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_sync.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_sync.c
index b57ca10a8533..4921de15b451 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_sync.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_sync.c
@@ -65,8 +65,14 @@ static bool amdgpu_sync_same_dev(struct amdgpu_device *adev, struct fence *f)
 
         if (a_fence)
                 return a_fence->ring->adev == adev;
-        if (s_fence)
-                return (struct amdgpu_device *)s_fence->sched->priv == adev;
+
+        if (s_fence) {
+                struct amdgpu_ring *ring;
+
+                ring = container_of(s_fence->sched, struct amdgpu_ring, sched);
+                return ring->adev == adev;
+        }
+
         return false;
 }