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>

3 files changed, 26 insertions, 39 deletions

diff --git a/drivers/gpu/drm/amd/scheduler/gpu_sched_trace.h b/drivers/gpu/drm/amd/scheduler/gpu_sched_trace.h
index a1f4ece58a24..144f50acc971 100644
--- a/drivers/gpu/drm/amd/scheduler/gpu_sched_trace.h
+++ b/drivers/gpu/drm/amd/scheduler/gpu_sched_trace.h
@@ -16,21 +16,21 @@ TRACE_EVENT(amd_sched_job,
             TP_ARGS(sched_job),
             TP_STRUCT__entry(
                              __field(struct amd_sched_entity *, entity)
-                             __field(u32, ring_id)
+                             __field(const char *, name)
                              __field(u32, job_count)
                              __field(int, hw_job_count)
                              ),
 
             TP_fast_assign(
                            __entry->entity = sched_job->s_entity;
-                           __entry->ring_id = sched_job->sched->ring_id;
+                           __entry->name = sched_job->sched->name;
                            __entry->job_count = kfifo_len(
                                    &sched_job->s_entity->job_queue) / sizeof(sched_job);
                            __entry->hw_job_count = atomic_read(
                                    &sched_job->sched->hw_rq_count);
                            ),
-            TP_printk("entity=%p, ring=%u, job count:%u, hw job count:%d",
-                      __entry->entity, __entry->ring_id, __entry->job_count,
+            TP_printk("entity=%p, ring=%s, job count:%u, hw job count:%d",
+                      __entry->entity, __entry->name, __entry->job_count,
                       __entry->hw_job_count)
 );
 #endif
diff --git a/drivers/gpu/drm/amd/scheduler/gpu_scheduler.c b/drivers/gpu/drm/amd/scheduler/gpu_scheduler.c
index ec4842e58fd7..3697eeeecf82 100644
--- a/drivers/gpu/drm/amd/scheduler/gpu_scheduler.c
+++ b/drivers/gpu/drm/amd/scheduler/gpu_scheduler.c
@@ -381,56 +381,45 @@ static int amd_sched_main(void *param)
 }
 
 /**
- * Create a gpu scheduler
+ * Init a gpu scheduler instance
  *
+ * @sched               The pointer to the scheduler
  * @ops                 The backend operations for this scheduler.
- * @ring                The the ring id for the scheduler.
  * @hw_submissions      Number of hw submissions to do.
+ * @name                Name used for debugging
  *
- * Return the pointer to scheduler for success, otherwise return NULL
+ * Return 0 on success, otherwise error code.
 */
-struct amd_gpu_scheduler *amd_sched_create(struct amd_sched_backend_ops *ops,
-                                           unsigned ring, unsigned hw_submission,
-                                           void *priv)
+int amd_sched_init(struct amd_gpu_scheduler *sched,
+                   struct amd_sched_backend_ops *ops,
+                   unsigned hw_submission, const char *name)
 {
-        struct amd_gpu_scheduler *sched;
-
-        sched = kzalloc(sizeof(struct amd_gpu_scheduler), GFP_KERNEL);
-        if (!sched)
-                return NULL;
-
         sched->ops = ops;
-        sched->ring_id = ring;
         sched->hw_submission_limit = hw_submission;
-        sched->priv = priv;
-        snprintf(sched->name, sizeof(sched->name), "amdgpu[%d]", ring);
+        sched->name = name;
         amd_sched_rq_init(&sched->sched_rq);
         amd_sched_rq_init(&sched->kernel_rq);
 
         init_waitqueue_head(&sched->wake_up_worker);
         init_waitqueue_head(&sched->job_scheduled);
         atomic_set(&sched->hw_rq_count, 0);
+
         /* Each scheduler will run on a seperate kernel thread */
         sched->thread = kthread_run(amd_sched_main, sched, sched->name);
         if (IS_ERR(sched->thread)) {
-                DRM_ERROR("Failed to create scheduler for id %d.\n", ring);
-                kfree(sched);
-                return NULL;
+                DRM_ERROR("Failed to create scheduler for %s.\n", name);
+                return PTR_ERR(sched->thread);
         }
 
-        return sched;
+        return 0;
 }
 
 /**
  * Destroy a gpu scheduler
  *
  * @sched       The pointer to the scheduler
- *
- * return 0 if succeed. -1 if failed.
  */
-int amd_sched_destroy(struct amd_gpu_scheduler *sched)
+void amd_sched_fini(struct amd_gpu_scheduler *sched)
 {
         kthread_stop(sched->thread);
-        kfree(sched);
-        return  0;
 }
diff --git a/drivers/gpu/drm/amd/scheduler/gpu_scheduler.h b/drivers/gpu/drm/amd/scheduler/gpu_scheduler.h
index 89d977dd30ac..80b64dc22214 100644
--- a/drivers/gpu/drm/amd/scheduler/gpu_scheduler.h
+++ b/drivers/gpu/drm/amd/scheduler/gpu_scheduler.h
@@ -101,23 +101,21 @@ struct amd_sched_backend_ops {
  * One scheduler is implemented for each hardware ring
 */
 struct amd_gpu_scheduler {
-        struct task_struct              *thread;
+        struct amd_sched_backend_ops    *ops;
+        uint32_t                        hw_submission_limit;
+        const char                      *name;
         struct amd_sched_rq             sched_rq;
         struct amd_sched_rq             kernel_rq;
-        atomic_t                        hw_rq_count;
-        struct amd_sched_backend_ops    *ops;
-        uint32_t                        ring_id;
         wait_queue_head_t               wake_up_worker;
         wait_queue_head_t               job_scheduled;
-        uint32_t                        hw_submission_limit;
-        char                            name[20];
-        void                            *priv;
+        atomic_t                        hw_rq_count;
+        struct task_struct              *thread;
 };
 
-struct amd_gpu_scheduler *
-amd_sched_create(struct amd_sched_backend_ops *ops,
-                 uint32_t ring, uint32_t hw_submission, void *priv);
-int amd_sched_destroy(struct amd_gpu_scheduler *sched);
+int amd_sched_init(struct amd_gpu_scheduler *sched,
+                   struct amd_sched_backend_ops *ops,
+                   uint32_t hw_submission, const char *name);
+void amd_sched_fini(struct amd_gpu_scheduler *sched);
 
 int amd_sched_entity_init(struct amd_gpu_scheduler *sched,
                           struct amd_sched_entity *entity,