drm/amdgpu: use amd_sched_job in its backend ops

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

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_sched.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_sched.c
index 039bd1f748f0cfe78ead8df4485c0ed88a17673d..d13d01511694246bd39606ee0b0752154f2b063f 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_sched.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_sched.c
@@ -29,10 +29,16 @@
 
 static int amdgpu_sched_prepare_job(struct amd_gpu_scheduler *sched,
                                    struct amd_sched_entity *entity,
-                                   void *job)
+                                   struct amd_sched_job *job)
 {
        int r = 0;
-       struct amdgpu_cs_parser *sched_job = (struct amdgpu_cs_parser *)job;
+       struct amdgpu_cs_parser *sched_job;
+       if (!job || !job->data) {
+               DRM_ERROR("job is null\n");
+               return -EINVAL;
+       }
+
+       sched_job = (struct amdgpu_cs_parser *)job->data;
        if (sched_job->prepare_job) {
                r = sched_job->prepare_job(sched_job);
                if (r) {
@@ -51,11 +57,11 @@ static struct fence *amdgpu_sched_run_job(struct amd_gpu_scheduler *sched,
        struct amdgpu_cs_parser *sched_job;
        struct amdgpu_fence *fence;
 
-       if (!job || !job->job) {
+       if (!job || !job->data) {
                DRM_ERROR("job is null\n");
                return NULL;
        }
-       sched_job = (struct amdgpu_cs_parser *)job->job;
+       sched_job = (struct amdgpu_cs_parser *)job->data;
        mutex_lock(&sched_job->job_lock);
        r = amdgpu_ib_schedule(sched_job->adev,
                               sched_job->num_ibs,
@@ -83,22 +89,16 @@ err:
        return NULL;
 }
 
-static void amdgpu_sched_process_job(struct amd_gpu_scheduler *sched, void *job)
+static void amdgpu_sched_process_job(struct amd_gpu_scheduler *sched,
+                                    struct amd_sched_job *job)
 {
-       struct amdgpu_cs_parser *sched_job = NULL;
-       struct amdgpu_fence *fence = NULL;
-       struct amdgpu_ring *ring = NULL;
-       struct amdgpu_device *adev = NULL;
+       struct amdgpu_cs_parser *sched_job;
 
-       if (!job)
-               return;
-       sched_job = (struct amdgpu_cs_parser *)job;
-       fence = sched_job->ibs[sched_job->num_ibs - 1].fence;
-       if (!fence)
+       if (!job || !job->data) {
+               DRM_ERROR("job is null\n");
                return;
-       ring = fence->ring;
-       adev = ring->adev;
-
+       }
+       sched_job = (struct amdgpu_cs_parser *)job->data;
        schedule_work(&sched_job->job_work);
 }
 

diff --git a/drivers/gpu/drm/amd/scheduler/gpu_scheduler.c b/drivers/gpu/drm/amd/scheduler/gpu_scheduler.c
index 438dc23f4bb38ec7a3ccd6f8ddb7923c04280039..33b4f55e48b10d79e7d2951f05744295a0e723c8 100644 (file)
--- a/drivers/gpu/drm/amd/scheduler/gpu_scheduler.c
+++ b/drivers/gpu/drm/amd/scheduler/gpu_scheduler.c
@@ -291,8 +291,15 @@ int amd_sched_entity_fini(struct amd_gpu_scheduler *sched,
 */
 int amd_sched_push_job(struct amd_gpu_scheduler *sched,
                       struct amd_sched_entity *c_entity,
-                      void *job)
+                      void *data)
 {
+       struct amd_sched_job *job = kzalloc(sizeof(struct amd_sched_job),
+                                           GFP_KERNEL);
+       if (!job)
+               return -ENOMEM;
+       job->sched = sched;
+       job->s_entity = c_entity;
+       job->data = data;
        while (kfifo_in_spinlocked(&c_entity->job_queue, &job, sizeof(void *),
                                   &c_entity->queue_lock) != sizeof(void *)) {
                /**
@@ -366,7 +373,7 @@ static void amd_sched_process_job(struct fence *f, struct fence_cb *cb)
        atomic64_dec(&sched->hw_rq_count);
        spin_unlock_irqrestore(&sched->queue_lock, flags);
 
-       sched->ops->process_job(sched, sched_job->job);
+       sched->ops->process_job(sched, sched_job);
        kfree(sched_job);
        wake_up_interruptible(&sched->wait_queue);
 }
@@ -374,7 +381,7 @@ static void amd_sched_process_job(struct fence *f, struct fence_cb *cb)
 static int amd_sched_main(void *param)
 {
        int r;
-       void *job;
+       struct amd_sched_job *job;
        struct sched_param sparam = {.sched_priority = 1};
        struct amd_sched_entity *c_entity = NULL;
        struct amd_gpu_scheduler *sched = (struct amd_gpu_scheduler *)param;
@@ -382,7 +389,6 @@ static int amd_sched_main(void *param)
        sched_setscheduler(current, SCHED_FIFO, &sparam);
 
        while (!kthread_should_stop()) {
-               struct amd_sched_job *sched_job = NULL;
                struct fence *fence;
 
                wait_event_interruptible(sched->wait_queue,
@@ -394,26 +400,18 @@ static int amd_sched_main(void *param)
                r = sched->ops->prepare_job(sched, c_entity, job);
                if (!r) {
                        unsigned long flags;
-                       sched_job = kzalloc(sizeof(struct amd_sched_job),
-                                           GFP_KERNEL);
-                       if (!sched_job) {
-                               WARN(true, "No memory to allocate\n");
-                               continue;
-                       }
-                       sched_job->job = job;
-                       sched_job->sched = sched;
                        spin_lock_irqsave(&sched->queue_lock, flags);
-                       list_add_tail(&sched_job->list, &sched->active_hw_rq);
+                       list_add_tail(&job->list, &sched->active_hw_rq);
                        atomic64_inc(&sched->hw_rq_count);
                        spin_unlock_irqrestore(&sched->queue_lock, flags);
                }
                mutex_lock(&sched->sched_lock);
-               fence = sched->ops->run_job(sched, c_entity, sched_job);
+               fence = sched->ops->run_job(sched, c_entity, job);
                if (fence) {
-                       r = fence_add_callback(fence, &sched_job->cb,
+                       r = fence_add_callback(fence, &job->cb,
                                               amd_sched_process_job);
                        if (r == -ENOENT)
-                               amd_sched_process_job(fence, &sched_job->cb);
+                               amd_sched_process_job(fence, &job->cb);
                        else if (r)
                                DRM_ERROR("fence add callback failed (%d)\n", r);
                        fence_put(fence);

diff --git a/drivers/gpu/drm/amd/scheduler/gpu_scheduler.h b/drivers/gpu/drm/amd/scheduler/gpu_scheduler.h
index e7cc40a6993b2371d57710a81b06dcdf1411a9c8..f54615d6a500486dcce8793499ec1b13f2b9cacb 100644 (file)
--- a/drivers/gpu/drm/amd/scheduler/gpu_scheduler.h
+++ b/drivers/gpu/drm/amd/scheduler/gpu_scheduler.h
@@ -76,7 +76,8 @@ struct amd_sched_job {
        struct list_head                list;
        struct fence_cb                 cb;
        struct amd_gpu_scheduler        *sched;
-       void                            *job;
+       struct amd_sched_entity         *s_entity;
+       void                            *data;
 };
 
 /**
@@ -86,11 +87,12 @@ struct amd_sched_job {
 struct amd_sched_backend_ops {
        int (*prepare_job)(struct amd_gpu_scheduler *sched,
                           struct amd_sched_entity *c_entity,
-                          void *job);
+                          struct amd_sched_job *job);
        struct fence *(*run_job)(struct amd_gpu_scheduler *sched,
                                 struct amd_sched_entity *c_entity,
                                 struct amd_sched_job *job);
-       void (*process_job)(struct amd_gpu_scheduler *sched, void *job);
+       void (*process_job)(struct amd_gpu_scheduler *sched,
+                                   struct amd_sched_job *job);
 };
 
 /**
@@ -120,12 +122,11 @@ struct amd_gpu_scheduler *amd_sched_create(void *device,
                                uint32_t granularity,
                                uint32_t preemption,
                                uint32_t hw_submission);
-
 int amd_sched_destroy(struct amd_gpu_scheduler *sched);
 
 int amd_sched_push_job(struct amd_gpu_scheduler *sched,
                       struct amd_sched_entity *c_entity,
-                      void *job);
+                      void *data);
 
 int amd_sched_wait_emit(struct amd_sched_entity *c_entity,
                        uint64_t seq,