[RFC PATCH 12/12] drm/panthor: Convert to drm_dep scheduler layer

[Matthew Brost]

Replace drm_gpu_scheduler/drm_sched_entity with the drm_dep layer
(struct drm_dep_queue / struct drm_dep_job) across all Panthor
submission paths: the CSF queue scheduler and the VM_BIND scheduler.

panthor_sched.c — CSF queue scheduler:
  struct panthor_queue drops the inline struct drm_gpu_scheduler and
  struct drm_sched_entity, replacing them with an embedded struct
  drm_dep_queue q.  The 1:1 scheduler:entity pairing that drm_sched
  required collapses into the single queue object.  queue_run_job() and
  queue_timedout_job() updated to drm_dep signatures and return types.
  queue_timedout_job() guards the reset path so it only fires once;
  returns DRM_DEP_TIMEDOUT_STAT_JOB_SIGNALED.  Stop/start on reset
  updated to drm_dep_queue_stop/start.  The timeout workqueue is
  accessed via drm_dep_queue_timeout_wq() for mod_delayed_work() calls.
  Queue teardown simplified from a multi-step disable_delayed_work_sync
  / entity_destroy / sched_fini sequence to drm_dep_queue_put().

  struct panthor_job drops struct drm_sched_job base and struct kref
  refcount in favour of struct drm_dep_job base.  panthor_job_get/put()
  updated to drm_dep_job_get/put().  job_release() becomes the .release
  vfunc on struct drm_dep_job_ops; job_release() body moves to
  job_cleanup() which is called from both the release vfunc and the
  init error path.  drm_sched_job_init replaced with drm_dep_job_init.
  panthor_job_update_resvs() updated to use drm_dep_job_finished_fence()
  instead of sched_job->s_fence->finished.

panthor_mmu.c — VM_BIND scheduler:
  struct panthor_vm drops the inline struct drm_gpu_scheduler and struct
  drm_sched_entity in favour of a heap-allocated struct drm_dep_queue *q.
  The queue is allocated with kzalloc_obj and freed via
  drm_dep_queue_put().  Queue init gains
  DRM_DEP_QUEUE_FLAGS_JOB_PUT_IRQ_SAFE and
  DRM_DEP_QUEUE_FLAGS_BYPASS_SUPPORTED flags appropriate for the VM_BIND
  path.  panthor_vm_bind_run_job() and panthor_vm_bind_timedout_job()
  updated to drm_dep signatures; timedout returns
  DRM_DEP_TIMEDOUT_STAT_JOB_SIGNALED.  panthor_vm_bind_job_release()
  becomes the .release vfunc; the old panthor_vm_bind_job_put() wrapper
  is replaced with drm_dep_job_put().  VM stop/start on reset path and
  destroy path updated to drm_dep_queue_stop/start/put.
  drm_dep_job_finished_fence() used in place of s_fence->finished.

Cc: Boris Brezillon <boris.brezillon@xxxxxxxxxxxxx>
Cc: Christian König <christian.koenig@xxxxxxx>
Cc: David Airlie <airlied@xxxxxxxxx>
Cc: dri-devel@xxxxxxxxxxxxxxxxxxxxx
Cc: Liviu Dudau <liviu.dudau@xxxxxxx>
Cc: Maarten Lankhorst <maarten.lankhorst@xxxxxxxxxxxxxxx>
Cc: Maxime Ripard <mripard@xxxxxxxxxx>
Cc: Simona Vetter <simona@xxxxxxxx>
Cc: Steven Price <steven.price@xxxxxxx>
Cc: Sumit Semwal <sumit.semwal@xxxxxxxxxx>
Cc: Thomas Zimmermann <tzimmermann@xxxxxxx>
Cc: linux-kernel@xxxxxxxxxxxxxxx
Signed-off-by: Matthew Brost <matthew.brost@xxxxxxxxx>
Assisted-by: GitHub Copilot:claude-sonnet-4.6
---
 drivers/gpu/drm/panthor/Kconfig          |   2 +-
 drivers/gpu/drm/panthor/panthor_device.c |   5 +-
 drivers/gpu/drm/panthor/panthor_device.h |   2 +-
 drivers/gpu/drm/panthor/panthor_drv.c    |  35 ++--
 drivers/gpu/drm/panthor/panthor_mmu.c    | 160 +++++++--------
 drivers/gpu/drm/panthor/panthor_mmu.h    |  14 +-
 drivers/gpu/drm/panthor/panthor_sched.c  | 242 +++++++++++------------
 drivers/gpu/drm/panthor/panthor_sched.h  |  12 +-
 8 files changed, 223 insertions(+), 249 deletions(-)

diff --git a/drivers/gpu/drm/panthor/Kconfig b/drivers/gpu/drm/panthor/Kconfig
index 55b40ad07f3b..e22f7dc33dff 100644
--- a/drivers/gpu/drm/panthor/Kconfig
+++ b/drivers/gpu/drm/panthor/Kconfig
@@ -10,7 +10,7 @@ config DRM_PANTHOR
 	select DRM_EXEC
 	select DRM_GEM_SHMEM_HELPER
 	select DRM_GPUVM
-	select DRM_SCHED
+	select DRM_DEP
 	select IOMMU_IO_PGTABLE_LPAE
 	select IOMMU_SUPPORT
 	select PM_DEVFREQ
diff --git a/drivers/gpu/drm/panthor/panthor_device.c b/drivers/gpu/drm/panthor/panthor_device.c
index 54fbb1aa07c5..66a01f26a52b 100644
--- a/drivers/gpu/drm/panthor/panthor_device.c
+++ b/drivers/gpu/drm/panthor/panthor_device.c
@@ -11,6 +11,7 @@
 #include <linux/regulator/consumer.h>
 #include <linux/reset.h>
 
+#include <drm/drm_dep.h>
 #include <drm/drm_drv.h>
 #include <drm/drm_managed.h>
 #include <drm/drm_print.h>
@@ -231,7 +232,9 @@ int panthor_device_init(struct panthor_device *ptdev)
 	*dummy_page_virt = 1;
 
 	INIT_WORK(&ptdev->reset.work, panthor_device_reset_work);
-	ptdev->reset.wq = alloc_ordered_workqueue("panthor-reset-wq", 0);
+	ptdev->reset.wq = alloc_ordered_workqueue("panthor-reset-wq",
+						  WQ_MEM_RECLAIM |
+						  WQ_MEM_WARN_ON_RECLAIM);
 	if (!ptdev->reset.wq)
 		return -ENOMEM;
 
diff --git a/drivers/gpu/drm/panthor/panthor_device.h b/drivers/gpu/drm/panthor/panthor_device.h
index b6696f73a536..d2c05c1ee513 100644
--- a/drivers/gpu/drm/panthor/panthor_device.h
+++ b/drivers/gpu/drm/panthor/panthor_device.h
@@ -15,7 +15,7 @@
 
 #include <drm/drm_device.h>
 #include <drm/drm_mm.h>
-#include <drm/gpu_scheduler.h>
+#include <drm/drm_dep.h>
 #include <drm/panthor_drm.h>
 
 struct panthor_csf;
diff --git a/drivers/gpu/drm/panthor/panthor_drv.c b/drivers/gpu/drm/panthor/panthor_drv.c
index 1bcec6a2e3e0..086f9f28c6be 100644
--- a/drivers/gpu/drm/panthor/panthor_drv.c
+++ b/drivers/gpu/drm/panthor/panthor_drv.c
@@ -23,7 +23,7 @@
 #include <drm/drm_print.h>
 #include <drm/drm_syncobj.h>
 #include <drm/drm_utils.h>
-#include <drm/gpu_scheduler.h>
+#include <drm/drm_dep.h>
 #include <drm/panthor_drm.h>
 
 #include "panthor_devfreq.h"
@@ -269,8 +269,8 @@ struct panthor_sync_signal {
  * struct panthor_job_ctx - Job context
  */
 struct panthor_job_ctx {
-	/** @job: The job that is about to be submitted to drm_sched. */
-	struct drm_sched_job *job;
+	/** @job: The job that is about to be submitted to drm_dep. */
+	struct drm_dep_job *job;
 
 	/** @syncops: Array of sync operations. */
 	struct drm_panthor_sync_op *syncops;
@@ -452,7 +452,7 @@ panthor_submit_ctx_search_sync_signal(struct panthor_submit_ctx *ctx, u32 handle
  */
 static int
 panthor_submit_ctx_add_job(struct panthor_submit_ctx *ctx, u32 idx,
-			   struct drm_sched_job *job,
+			   struct drm_dep_job *job,
 			   const struct drm_panthor_obj_array *syncs)
 {
 	int ret;
@@ -502,7 +502,7 @@ panthor_submit_ctx_update_job_sync_signal_fences(struct panthor_submit_ctx *ctx,
 	struct panthor_device *ptdev = container_of(ctx->file->minor->dev,
 						    struct panthor_device,
 						    base);
-	struct dma_fence *done_fence = &ctx->jobs[job_idx].job->s_fence->finished;
+	struct dma_fence *done_fence = drm_dep_job_finished_fence(ctx->jobs[job_idx].job);
 	const struct drm_panthor_sync_op *sync_ops = ctx->jobs[job_idx].syncops;
 	u32 sync_op_count = ctx->jobs[job_idx].syncop_count;
 
@@ -604,7 +604,7 @@ panthor_submit_ctx_add_sync_deps_to_job(struct panthor_submit_ctx *ctx,
 						    struct panthor_device,
 						    base);
 	const struct drm_panthor_sync_op *sync_ops = ctx->jobs[job_idx].syncops;
-	struct drm_sched_job *job = ctx->jobs[job_idx].job;
+	struct drm_dep_job *job = ctx->jobs[job_idx].job;
 	u32 sync_op_count = ctx->jobs[job_idx].syncop_count;
 	int ret = 0;
 
@@ -634,7 +634,7 @@ panthor_submit_ctx_add_sync_deps_to_job(struct panthor_submit_ctx *ctx,
 				return ret;
 		}
 
-		ret = drm_sched_job_add_dependency(job, fence);
+		ret = drm_dep_job_add_dependency(job, fence);
 		if (ret)
 			return ret;
 	}
@@ -681,8 +681,11 @@ panthor_submit_ctx_add_deps_and_arm_jobs(struct panthor_submit_ctx *ctx)
 		if (ret)
 			return ret;
 
-		drm_sched_job_arm(ctx->jobs[i].job);
+		drm_dep_job_arm(ctx->jobs[i].job);
 
+		/*
+		 * XXX: Failing path hazard... per DRM dep this is not allowed
+		 */
 		ret = panthor_submit_ctx_update_job_sync_signal_fences(ctx, i);
 		if (ret)
 			return ret;
@@ -699,11 +702,11 @@ panthor_submit_ctx_add_deps_and_arm_jobs(struct panthor_submit_ctx *ctx)
  */
 static void
 panthor_submit_ctx_push_jobs(struct panthor_submit_ctx *ctx,
-			     void (*upd_resvs)(struct drm_exec *, struct drm_sched_job *))
+			     void (*upd_resvs)(struct drm_exec *, struct drm_dep_job *))
 {
 	for (u32 i = 0; i < ctx->job_count; i++) {
 		upd_resvs(&ctx->exec, ctx->jobs[i].job);
-		drm_sched_entity_push_job(ctx->jobs[i].job);
+		drm_dep_job_push(ctx->jobs[i].job);
 
 		/* Job is owned by the scheduler now. */
 		ctx->jobs[i].job = NULL;
@@ -743,7 +746,7 @@ static int panthor_submit_ctx_init(struct panthor_submit_ctx *ctx,
  * @job_put: Job put callback.
  */
 static void panthor_submit_ctx_cleanup(struct panthor_submit_ctx *ctx,
-				       void (*job_put)(struct drm_sched_job *))
+				       void (*job_put)(struct drm_dep_job *))
 {
 	struct panthor_sync_signal *sig_sync, *tmp;
 	unsigned long i;
@@ -1004,7 +1007,7 @@ static int panthor_ioctl_group_submit(struct drm_device *ddev, void *data,
 	/* Create jobs and attach sync operations */
 	for (u32 i = 0; i < args->queue_submits.count; i++) {
 		const struct drm_panthor_queue_submit *qsubmit = &jobs_args[i];
-		struct drm_sched_job *job;
+		struct drm_dep_job *job;
 
 		job = panthor_job_create(pfile, args->group_handle, qsubmit,
 					 file->client_id);
@@ -1032,11 +1035,11 @@ static int panthor_ioctl_group_submit(struct drm_device *ddev, void *data,
 	 * dependency registration.
 	 *
 	 * This is solving two problems:
-	 * 1. drm_sched_job_arm() and drm_sched_entity_push_job() must be
+	 * 1. drm_dep_job_arm() and drm_dep_job_push() must be
 	 *    protected by a lock to make sure no concurrent access to the same
-	 *    entity get interleaved, which would mess up with the fence seqno
+	 *    queue gets interleaved, which would mess up with the fence seqno
 	 *    ordering. Luckily, one of the resv being acquired is the VM resv,
-	 *    and a scheduling entity is only bound to a single VM. As soon as
+	 *    and a dep queue is only bound to a single VM. As soon as
 	 *    we acquire the VM resv, we should be safe.
 	 * 2. Jobs might depend on fences that were issued by previous jobs in
 	 *    the same batch, so we can't add dependencies on all jobs before
@@ -1232,7 +1235,7 @@ static int panthor_ioctl_vm_bind_async(struct drm_device *ddev,
 
 	for (u32 i = 0; i < args->ops.count; i++) {
 		struct drm_panthor_vm_bind_op *op = &jobs_args[i];
-		struct drm_sched_job *job;
+		struct drm_dep_job *job;
 
 		job = panthor_vm_bind_job_create(file, vm, op);
 		if (IS_ERR(job)) {
diff --git a/drivers/gpu/drm/panthor/panthor_mmu.c b/drivers/gpu/drm/panthor/panthor_mmu.c
index f8c41e36afa4..45e5f0d71594 100644
--- a/drivers/gpu/drm/panthor/panthor_mmu.c
+++ b/drivers/gpu/drm/panthor/panthor_mmu.c
@@ -8,7 +8,7 @@
 #include <drm/drm_gpuvm.h>
 #include <drm/drm_managed.h>
 #include <drm/drm_print.h>
-#include <drm/gpu_scheduler.h>
+#include <drm/drm_dep.h>
 #include <drm/panthor_drm.h>
 
 #include <linux/atomic.h>
@@ -232,19 +232,9 @@ struct panthor_vm {
 	struct drm_gpuvm base;
 
 	/**
-	 * @sched: Scheduler used for asynchronous VM_BIND request.
-	 *
-	 * We use a 1:1 scheduler here.
-	 */
-	struct drm_gpu_scheduler sched;
-
-	/**
-	 * @entity: Scheduling entity representing the VM_BIND queue.
-	 *
-	 * There's currently one bind queue per VM. It doesn't make sense to
-	 * allow more given the VM operations are serialized anyway.
+	 * @q: Dep queue used for asynchronous VM_BIND request.
 	 */
-	struct drm_sched_entity entity;
+	struct drm_dep_queue *q;
 
 	/** @ptdev: Device. */
 	struct panthor_device *ptdev;
@@ -262,7 +252,7 @@ struct panthor_vm {
 	 * @op_lock: Lock used to serialize operations on a VM.
 	 *
 	 * The serialization of jobs queued to the VM_BIND queue is already
-	 * taken care of by drm_sched, but we need to serialize synchronous
+	 * taken care of by drm_dep, but we need to serialize synchronous
 	 * and asynchronous VM_BIND request. This is what this lock is for.
 	 */
 	struct mutex op_lock;
@@ -390,11 +380,8 @@ struct panthor_vm {
  * struct panthor_vm_bind_job - VM bind job
  */
 struct panthor_vm_bind_job {
-	/** @base: Inherit from drm_sched_job. */
-	struct drm_sched_job base;
-
-	/** @refcount: Reference count. */
-	struct kref refcount;
+	/** @base: Inherit from drm_dep_job. */
+	struct drm_dep_job base;
 
 	/** @cleanup_op_ctx_work: Work used to cleanup the VM operation context. */
 	struct work_struct cleanup_op_ctx_work;
@@ -821,12 +808,12 @@ u32 panthor_vm_page_size(struct panthor_vm *vm)
 
 static void panthor_vm_stop(struct panthor_vm *vm)
 {
-	drm_sched_stop(&vm->sched, NULL);
+	drm_dep_queue_stop(vm->q);
 }
 
 static void panthor_vm_start(struct panthor_vm *vm)
 {
-	drm_sched_start(&vm->sched, 0);
+	drm_dep_queue_start(vm->q);
 }
 
 /**
@@ -1882,17 +1869,17 @@ static void panthor_vm_free(struct drm_gpuvm *gpuvm)
 
 	mutex_lock(&ptdev->mmu->vm.lock);
 	list_del(&vm->node);
-	/* Restore the scheduler state so we can call drm_sched_entity_destroy()
-	 * and drm_sched_fini(). If get there, that means we have no job left
-	 * and no new jobs can be queued, so we can start the scheduler without
+	/* Restore the queue state so we can call drm_dep_queue_put().
+	 * If we get there, that means we have no job left
+	 * and no new jobs can be queued, so we can start the queue without
 	 * risking interfering with the reset.
 	 */
 	if (ptdev->mmu->vm.reset_in_progress)
 		panthor_vm_start(vm);
 	mutex_unlock(&ptdev->mmu->vm.lock);
 
-	drm_sched_entity_destroy(&vm->entity);
-	drm_sched_fini(&vm->sched);
+	drm_dep_queue_kill(vm->q);
+	drm_dep_queue_put(vm->q);
 
 	mutex_lock(&vm->op_lock);
 	mutex_lock(&ptdev->mmu->as.slots_lock);
@@ -2319,14 +2306,14 @@ panthor_vm_exec_op(struct panthor_vm *vm, struct panthor_vm_op_ctx *op,
 }
 
 static struct dma_fence *
-panthor_vm_bind_run_job(struct drm_sched_job *sched_job)
+panthor_vm_bind_run_job(struct drm_dep_job *dep_job)
 {
-	struct panthor_vm_bind_job *job = container_of(sched_job, struct panthor_vm_bind_job, base);
+	struct panthor_vm_bind_job *job = container_of(dep_job, struct panthor_vm_bind_job, base);
 	bool cookie;
 	int ret;
 
 	/* Not only we report an error whose result is propagated to the
-	 * drm_sched finished fence, but we also flag the VM as unusable, because
+	 * drm_dep finished fence, but we also flag the VM as unusable, because
 	 * a failure in the async VM_BIND results in an inconsistent state. VM needs
 	 * to be destroyed and recreated.
 	 */
@@ -2337,38 +2324,24 @@ panthor_vm_bind_run_job(struct drm_sched_job *sched_job)
 	return ret ? ERR_PTR(ret) : NULL;
 }
 
-static void panthor_vm_bind_job_release(struct kref *kref)
+static void panthor_vm_bind_job_cleanup(struct panthor_vm_bind_job *job)
 {
-	struct panthor_vm_bind_job *job = container_of(kref, struct panthor_vm_bind_job, refcount);
-
-	if (job->base.s_fence)
-		drm_sched_job_cleanup(&job->base);
-
 	panthor_vm_cleanup_op_ctx(&job->ctx, job->vm);
 	panthor_vm_put(job->vm);
 	kfree(job);
 }
 
-/**
- * panthor_vm_bind_job_put() - Release a VM_BIND job reference
- * @sched_job: Job to release the reference on.
- */
-void panthor_vm_bind_job_put(struct drm_sched_job *sched_job)
+static void panthor_vm_bind_job_cleanup_op_ctx_work(struct work_struct *work)
 {
 	struct panthor_vm_bind_job *job =
-		container_of(sched_job, struct panthor_vm_bind_job, base);
+		container_of(work, struct panthor_vm_bind_job, cleanup_op_ctx_work);
 
-	if (sched_job)
-		kref_put(&job->refcount, panthor_vm_bind_job_release);
+	panthor_vm_bind_job_cleanup(job);
 }
 
-static void
-panthor_vm_bind_free_job(struct drm_sched_job *sched_job)
+static void panthor_vm_bind_job_release(struct drm_dep_job *dep_job)
 {
-	struct panthor_vm_bind_job *job =
-		container_of(sched_job, struct panthor_vm_bind_job, base);
-
-	drm_sched_job_cleanup(sched_job);
+	struct panthor_vm_bind_job *job = container_of(dep_job, struct panthor_vm_bind_job, base);
 
 	/* Do the heavy cleanups asynchronously, so we're out of the
 	 * dma-signaling path and can acquire dma-resv locks safely.
@@ -2376,16 +2349,29 @@ panthor_vm_bind_free_job(struct drm_sched_job *sched_job)
 	queue_work(panthor_cleanup_wq, &job->cleanup_op_ctx_work);
 }
 
-static enum drm_gpu_sched_stat
-panthor_vm_bind_timedout_job(struct drm_sched_job *sched_job)
+static const struct drm_dep_job_ops panthor_vm_bind_job_ops = {
+	.release = panthor_vm_bind_job_release,
+};
+
+/**
+ * panthor_vm_bind_job_put() - Release a VM_BIND job reference
+ * @dep_job: Job to release the reference on.
+ */
+void panthor_vm_bind_job_put(struct drm_dep_job *dep_job)
+{
+	if (dep_job)
+		drm_dep_job_put(dep_job);
+}
+
+static enum drm_dep_timedout_stat
+panthor_vm_bind_timedout_job(struct drm_dep_job *dep_job)
 {
 	WARN(1, "VM_BIND ops are synchronous for now, there should be no timeout!");
-	return DRM_GPU_SCHED_STAT_RESET;
+	return DRM_DEP_TIMEDOUT_STAT_JOB_SIGNALED;
 }
 
-static const struct drm_sched_backend_ops panthor_vm_bind_ops = {
+static const struct drm_dep_queue_ops panthor_vm_bind_ops = {
 	.run_job = panthor_vm_bind_run_job,
-	.free_job = panthor_vm_bind_free_job,
 	.timedout_job = panthor_vm_bind_timedout_job,
 };
 
@@ -2409,16 +2395,16 @@ panthor_vm_create(struct panthor_device *ptdev, bool for_mcu,
 	u32 pa_bits = GPU_MMU_FEATURES_PA_BITS(ptdev->gpu_info.mmu_features);
 	u64 full_va_range = 1ull << va_bits;
 	struct drm_gem_object *dummy_gem;
-	struct drm_gpu_scheduler *sched;
-	const struct drm_sched_init_args sched_args = {
+	const struct drm_dep_queue_init_args q_args = {
 		.ops = &panthor_vm_bind_ops,
 		.submit_wq = ptdev->mmu->vm.wq,
-		.num_rqs = 1,
 		.credit_limit = 1,
 		/* Bind operations are synchronous for now, no timeout needed. */
 		.timeout = MAX_SCHEDULE_TIMEOUT,
 		.name = "panthor-vm-bind",
-		.dev = ptdev->base.dev,
+		.drm = &ptdev->base,
+		.flags = DRM_DEP_QUEUE_FLAGS_JOB_PUT_IRQ_SAFE |
+			DRM_DEP_QUEUE_FLAGS_BYPASS_SUPPORTED,
 	};
 	struct io_pgtable_cfg pgtbl_cfg;
 	u64 mair, min_va, va_range;
@@ -2477,14 +2463,17 @@ panthor_vm_create(struct panthor_device *ptdev, bool for_mcu,
 		goto err_mm_takedown;
 	}
 
-	ret = drm_sched_init(&vm->sched, &sched_args);
-	if (ret)
+	vm->q = kzalloc_obj(*vm->q);
+	if (!vm->q) {
+		ret = -ENOMEM;
 		goto err_free_io_pgtable;
+	}
 
-	sched = &vm->sched;
-	ret = drm_sched_entity_init(&vm->entity, 0, &sched, 1, NULL);
-	if (ret)
-		goto err_sched_fini;
+	ret = drm_dep_queue_init(vm->q, &q_args);
+	if (ret) {
+		kfree(vm->q);
+		goto err_free_io_pgtable;
+	}
 
 	mair = io_pgtable_ops_to_pgtable(vm->pgtbl_ops)->cfg.arm_lpae_s1_cfg.mair;
 	vm->memattr = mair_to_memattr(mair, ptdev->coherent);
@@ -2492,7 +2481,7 @@ panthor_vm_create(struct panthor_device *ptdev, bool for_mcu,
 	mutex_lock(&ptdev->mmu->vm.lock);
 	list_add_tail(&vm->node, &ptdev->mmu->vm.list);
 
-	/* If a reset is in progress, stop the scheduler. */
+	/* If a reset is in progress, stop the queue. */
 	if (ptdev->mmu->vm.reset_in_progress)
 		panthor_vm_stop(vm);
 	mutex_unlock(&ptdev->mmu->vm.lock);
@@ -2507,9 +2496,6 @@ panthor_vm_create(struct panthor_device *ptdev, bool for_mcu,
 	drm_gem_object_put(dummy_gem);
 	return vm;
 
-err_sched_fini:
-	drm_sched_fini(&vm->sched);
-
 err_free_io_pgtable:
 	free_io_pgtable_ops(vm->pgtbl_ops);
 
@@ -2578,14 +2564,6 @@ panthor_vm_bind_prepare_op_ctx(struct drm_file *file,
 	}
 }
 
-static void panthor_vm_bind_job_cleanup_op_ctx_work(struct work_struct *work)
-{
-	struct panthor_vm_bind_job *job =
-		container_of(work, struct panthor_vm_bind_job, cleanup_op_ctx_work);
-
-	panthor_vm_bind_job_put(&job->base);
-}
-
 /**
  * panthor_vm_bind_job_create() - Create a VM_BIND job
  * @file: File.
@@ -2594,7 +2572,7 @@ static void panthor_vm_bind_job_cleanup_op_ctx_work(struct work_struct *work)
  *
  * Return: A valid pointer on success, an ERR_PTR() otherwise.
  */
-struct drm_sched_job *
+struct drm_dep_job *
 panthor_vm_bind_job_create(struct drm_file *file,
 			   struct panthor_vm *vm,
 			   const struct drm_panthor_vm_bind_op *op)
@@ -2619,17 +2597,21 @@ panthor_vm_bind_job_create(struct drm_file *file,
 	}
 
 	INIT_WORK(&job->cleanup_op_ctx_work, panthor_vm_bind_job_cleanup_op_ctx_work);
-	kref_init(&job->refcount);
 	job->vm = panthor_vm_get(vm);
 
-	ret = drm_sched_job_init(&job->base, &vm->entity, 1, vm, file->client_id);
+	ret = drm_dep_job_init(&job->base,
+			       &(struct drm_dep_job_init_args){
+					.ops = &panthor_vm_bind_job_ops,
+					.q = vm->q,
+					.credits = 1,
+			       });
 	if (ret)
-		goto err_put_job;
+		goto err_cleanup;
 
 	return &job->base;
 
-err_put_job:
-	panthor_vm_bind_job_put(&job->base);
+err_cleanup:
+	panthor_vm_bind_job_cleanup(job);
 	return ERR_PTR(ret);
 }
 
@@ -2645,9 +2627,9 @@ panthor_vm_bind_job_create(struct drm_file *file,
  * Return: 0 on success, a negative error code otherwise.
  */
 int panthor_vm_bind_job_prepare_resvs(struct drm_exec *exec,
-				      struct drm_sched_job *sched_job)
+				      struct drm_dep_job *dep_job)
 {
-	struct panthor_vm_bind_job *job = container_of(sched_job, struct panthor_vm_bind_job, base);
+	struct panthor_vm_bind_job *job = container_of(dep_job, struct panthor_vm_bind_job, base);
 	int ret;
 
 	/* Acquire the VM lock an reserve a slot for this VM bind job. */
@@ -2671,13 +2653,13 @@ int panthor_vm_bind_job_prepare_resvs(struct drm_exec *exec,
  * @sched_job: Job to update the resvs on.
  */
 void panthor_vm_bind_job_update_resvs(struct drm_exec *exec,
-				      struct drm_sched_job *sched_job)
+				      struct drm_dep_job *dep_job)
 {
-	struct panthor_vm_bind_job *job = container_of(sched_job, struct panthor_vm_bind_job, base);
+	struct panthor_vm_bind_job *job = container_of(dep_job, struct panthor_vm_bind_job, base);
 
 	/* Explicit sync => we just register our job finished fence as bookkeep. */
 	drm_gpuvm_resv_add_fence(&job->vm->base, exec,
-				 &sched_job->s_fence->finished,
+				 drm_dep_job_finished_fence(dep_job),
 				 DMA_RESV_USAGE_BOOKKEEP,
 				 DMA_RESV_USAGE_BOOKKEEP);
 }
@@ -2873,7 +2855,9 @@ int panthor_mmu_init(struct panthor_device *ptdev)
 	if (ret)
 		return ret;
 
-	mmu->vm.wq = alloc_workqueue("panthor-vm-bind", WQ_UNBOUND, 0);
+	mmu->vm.wq = alloc_workqueue("panthor-vm-bind", WQ_MEM_RECLAIM |
+				     WQ_MEM_WARN_ON_RECLAIM |
+				     WQ_UNBOUND, 0);
 	if (!mmu->vm.wq)
 		return -ENOMEM;
 
diff --git a/drivers/gpu/drm/panthor/panthor_mmu.h b/drivers/gpu/drm/panthor/panthor_mmu.h
index 0e268fdfdb2f..845f45ce7739 100644
--- a/drivers/gpu/drm/panthor/panthor_mmu.h
+++ b/drivers/gpu/drm/panthor/panthor_mmu.h
@@ -8,7 +8,7 @@
 #include <linux/dma-resv.h>
 
 struct drm_exec;
-struct drm_sched_job;
+struct drm_dep_job;
 struct drm_memory_stats;
 struct panthor_gem_object;
 struct panthor_heap_pool;
@@ -50,9 +50,9 @@ int panthor_vm_prepare_mapped_bos_resvs(struct drm_exec *exec,
 					struct panthor_vm *vm,
 					u32 slot_count);
 int panthor_vm_add_bos_resvs_deps_to_job(struct panthor_vm *vm,
-					 struct drm_sched_job *job);
+					 struct drm_dep_job *job);
 void panthor_vm_add_job_fence_to_bos_resvs(struct panthor_vm *vm,
-					   struct drm_sched_job *job);
+					   struct drm_dep_job *job);
 
 struct dma_resv *panthor_vm_resv(struct panthor_vm *vm);
 struct drm_gem_object *panthor_vm_root_gem(struct panthor_vm *vm);
@@ -82,14 +82,14 @@ int panthor_vm_bind_exec_sync_op(struct drm_file *file,
 				 struct panthor_vm *vm,
 				 struct drm_panthor_vm_bind_op *op);
 
-struct drm_sched_job *
+struct drm_dep_job *
 panthor_vm_bind_job_create(struct drm_file *file,
 			   struct panthor_vm *vm,
 			   const struct drm_panthor_vm_bind_op *op);
-void panthor_vm_bind_job_put(struct drm_sched_job *job);
+void panthor_vm_bind_job_put(struct drm_dep_job *job);
 int panthor_vm_bind_job_prepare_resvs(struct drm_exec *exec,
-				      struct drm_sched_job *job);
-void panthor_vm_bind_job_update_resvs(struct drm_exec *exec, struct drm_sched_job *job);
+				      struct drm_dep_job *job);
+void panthor_vm_bind_job_update_resvs(struct drm_exec *exec, struct drm_dep_job *job);
 
 void panthor_vm_update_resvs(struct panthor_vm *vm, struct drm_exec *exec,
 			     struct dma_fence *fence,
diff --git a/drivers/gpu/drm/panthor/panthor_sched.c b/drivers/gpu/drm/panthor/panthor_sched.c
index 2fe04d0f0e3a..040bea0688c3 100644
--- a/drivers/gpu/drm/panthor/panthor_sched.c
+++ b/drivers/gpu/drm/panthor/panthor_sched.c
@@ -6,7 +6,7 @@
 #include <drm/drm_gem_shmem_helper.h>
 #include <drm/drm_managed.h>
 #include <drm/drm_print.h>
-#include <drm/gpu_scheduler.h>
+#include <drm/drm_dep.h>
 #include <drm/panthor_drm.h>
 
 #include <linux/build_bug.h>
@@ -61,13 +61,11 @@
  * always gets consistent results (cache maintenance,
  * synchronization, ...).
  *
- * We rely on the drm_gpu_scheduler framework to deal with job
- * dependencies and submission. As any other driver dealing with a
- * FW-scheduler, we use the 1:1 entity:scheduler mode, such that each
- * entity has its own job scheduler. When a job is ready to be executed
- * (all its dependencies are met), it is pushed to the appropriate
- * queue ring-buffer, and the group is scheduled for execution if it
- * wasn't already active.
+ * We rely on the drm_dep framework to deal with job
+ * dependencies and submission. Each queue owns its own dep queue. When a job
+ * is ready to be executed (all its dependencies are met), it is pushed to the
+ * appropriate queue ring-buffer, and the group is scheduled for execution if
+ * it wasn't already active.
  *
  * Kernel-side group scheduling is timeslice-based. When we have less
  * groups than there are slots, the periodic tick is disabled and we
@@ -83,7 +81,7 @@
  * if userspace was in charge of the ring-buffer. That's also one of the
  * reason we don't do 'cooperative' scheduling (encoding FW group slot
  * reservation as dma_fence that would be returned from the
- * drm_gpu_scheduler::prepare_job() hook, and treating group rotation as
+ * drm_dep_queue_ops::prepare_job() hook, and treating group rotation as
  * a queue of waiters, ordered by job submission order). This approach
  * would work for kernel-mode queues, but would make user-mode queues a
  * lot more complicated to retrofit.
@@ -147,11 +145,11 @@ struct panthor_scheduler {
 
 	/**
 	 * @wq: Workqueue used by our internal scheduler logic and
-	 * drm_gpu_scheduler.
+	 * drm_dep queues.
 	 *
 	 * Used for the scheduler tick, group update or other kind of FW
 	 * event processing that can't be handled in the threaded interrupt
-	 * path. Also passed to the drm_gpu_scheduler instances embedded
+	 * path. Also passed to the drm_dep_queue instances embedded
 	 * in panthor_queue.
 	 */
 	struct workqueue_struct *wq;
@@ -347,13 +345,10 @@ struct panthor_syncobj_64b {
  * struct panthor_queue - Execution queue
  */
 struct panthor_queue {
-	/** @scheduler: DRM scheduler used for this queue. */
-	struct drm_gpu_scheduler scheduler;
+	/** @q: drm_dep queue used for this queue. */
+	struct drm_dep_queue q;
 
-	/** @entity: DRM scheduling entity used for this queue. */
-	struct drm_sched_entity entity;
-
-	/** @name: DRM scheduler name for this queue. */
+	/** @name: dep queue name for this queue. */
 	char *name;
 
 	/** @timeout: Queue timeout related fields. */
@@ -461,7 +456,7 @@ struct panthor_queue {
 		 *
 		 * We return this fence when we get an empty command stream.
 		 * This way, we are guaranteed that all earlier jobs have completed
-		 * when drm_sched_job::s_fence::finished without having to feed
+		 * when the drm_dep finished fence is signaled without having to feed
 		 * the CS ring buffer with a dummy job that only signals the fence.
 		 */
 		struct dma_fence *last_fence;
@@ -599,7 +594,7 @@ struct panthor_group {
 	 * @timedout: True when a timeout occurred on any of the queues owned by
 	 * this group.
 	 *
-	 * Timeouts can be reported by drm_sched or by the FW. If a reset is required,
+	 * Timeouts can be reported by drm_dep or by the FW. If a reset is required,
 	 * and the group can't be suspended, this also leads to a timeout. In any case,
 	 * any timeout situation is unrecoverable, and the group becomes useless. We
 	 * simply wait for all references to be dropped so we can release the group
@@ -791,11 +786,8 @@ struct panthor_group_pool {
  * struct panthor_job - Used to manage GPU job
  */
 struct panthor_job {
-	/** @base: Inherit from drm_sched_job. */
-	struct drm_sched_job base;
-
-	/** @refcount: Reference count. */
-	struct kref refcount;
+	/** @base: Inherit from drm_dep_job. */
+	struct drm_dep_job base;
 
 	/** @group: Group of the queue this job will be pushed to. */
 	struct panthor_group *group;
@@ -915,27 +907,8 @@ static void group_free_queue(struct panthor_group *group, struct panthor_queue *
 	if (IS_ERR_OR_NULL(queue))
 		return;
 
-	/* Disable the timeout before tearing down drm_sched components. */
-	disable_delayed_work_sync(&queue->timeout.work);
-
-	if (queue->entity.fence_context)
-		drm_sched_entity_destroy(&queue->entity);
-
-	if (queue->scheduler.ops)
-		drm_sched_fini(&queue->scheduler);
-
-	kfree(queue->name);
-
-	panthor_queue_put_syncwait_obj(queue);
-
-	panthor_kernel_bo_destroy(queue->ringbuf);
-	panthor_kernel_bo_destroy(queue->iface.mem);
-	panthor_kernel_bo_destroy(queue->profiling.slots);
-
-	/* Release the last_fence we were holding, if any. */
-	dma_fence_put(queue->fence_ctx.last_fence);
-
-	kfree(queue);
+	if (queue->q.ops)
+		drm_dep_queue_put(&queue->q);
 }
 
 static void group_release_work(struct work_struct *work)
@@ -1098,7 +1071,7 @@ queue_reset_timeout_locked(struct panthor_queue *queue)
 	lockdep_assert_held(&queue->fence_ctx.lock);
 
 	if (!queue_timeout_is_suspended(queue)) {
-		mod_delayed_work(queue->scheduler.timeout_wq,
+		mod_delayed_work(drm_dep_queue_timeout_wq(&queue->q),
 				 &queue->timeout.work,
 				 msecs_to_jiffies(JOB_TIMEOUT_MS));
 	}
@@ -1162,7 +1135,7 @@ queue_resume_timeout(struct panthor_queue *queue)
 	spin_lock(&queue->fence_ctx.lock);
 
 	if (queue_timeout_is_suspended(queue)) {
-		mod_delayed_work(queue->scheduler.timeout_wq,
+		mod_delayed_work(drm_dep_queue_timeout_wq(&queue->q),
 				 &queue->timeout.work,
 				 queue->timeout.remaining);
 
@@ -2726,19 +2699,13 @@ static void queue_stop(struct panthor_queue *queue,
 		       struct panthor_job *bad_job)
 {
 	disable_delayed_work_sync(&queue->timeout.work);
-	drm_sched_stop(&queue->scheduler, bad_job ? &bad_job->base : NULL);
+	drm_dep_queue_stop(&queue->q);
 }
 
 static void queue_start(struct panthor_queue *queue)
 {
-	struct panthor_job *job;
-
-	/* Re-assign the parent fences. */
-	list_for_each_entry(job, &queue->scheduler.pending_list, base.list)
-		job->base.s_fence->parent = dma_fence_get(job->done_fence);
-
 	enable_delayed_work(&queue->timeout.work);
-	drm_sched_start(&queue->scheduler, 0);
+	drm_dep_queue_start(&queue->q);
 }
 
 static void panthor_group_stop(struct panthor_group *group)
@@ -3293,9 +3260,9 @@ static u32 calc_job_credits(u32 profile_mask)
 }
 
 static struct dma_fence *
-queue_run_job(struct drm_sched_job *sched_job)
+queue_run_job(struct drm_dep_job *dep_job)
 {
-	struct panthor_job *job = container_of(sched_job, struct panthor_job, base);
+	struct panthor_job *job = container_of(dep_job, struct panthor_job, base);
 	struct panthor_group *group = job->group;
 	struct panthor_queue *queue = group->queues[job->queue_idx];
 	struct panthor_device *ptdev = group->ptdev;
@@ -3306,8 +3273,7 @@ queue_run_job(struct drm_sched_job *sched_job)
 	int ret;
 
 	/* Stream size is zero, nothing to do except making sure all previously
-	 * submitted jobs are done before we signal the
-	 * drm_sched_job::s_fence::finished fence.
+	 * submitted jobs are done before we signal the drm_dep finished fence.
 	 */
 	if (!job->call_info.size) {
 		job->done_fence = dma_fence_get(queue->fence_ctx.last_fence);
@@ -3394,10 +3360,10 @@ queue_run_job(struct drm_sched_job *sched_job)
 	return done_fence;
 }
 
-static enum drm_gpu_sched_stat
-queue_timedout_job(struct drm_sched_job *sched_job)
+static enum drm_dep_timedout_stat
+queue_timedout_job(struct drm_dep_job *dep_job)
 {
-	struct panthor_job *job = container_of(sched_job, struct panthor_job, base);
+	struct panthor_job *job = container_of(dep_job, struct panthor_job, base);
 	struct panthor_group *group = job->group;
 	struct panthor_device *ptdev = group->ptdev;
 	struct panthor_scheduler *sched = ptdev->scheduler;
@@ -3411,34 +3377,58 @@ queue_timedout_job(struct drm_sched_job *sched_job)
 	queue_stop(queue, job);
 
 	mutex_lock(&sched->lock);
-	group->timedout = true;
-	if (group->csg_id >= 0) {
-		sched_queue_delayed_work(ptdev->scheduler, tick, 0);
-	} else {
-		/* Remove from the run queues, so the scheduler can't
-		 * pick the group on the next tick.
-		 */
-		list_del_init(&group->run_node);
-		list_del_init(&group->wait_node);
+	if (!group->timedout) {
+		group->timedout = true;
+		if (group->csg_id >= 0) {
+			sched_queue_delayed_work(ptdev->scheduler, tick, 0);
+		} else {
+			/* Remove from the run queues, so the scheduler can't
+			 * pick the group on the next tick.
+			 */
+			list_del_init(&group->run_node);
+			list_del_init(&group->wait_node);
 
-		group_queue_work(group, term);
+			group_queue_work(group, term);
+		}
 	}
 	mutex_unlock(&sched->lock);
 
 	queue_start(queue);
-	return DRM_GPU_SCHED_STAT_RESET;
+	if (drm_dep_job_is_finished(dep_job))
+		return DRM_DEP_TIMEDOUT_STAT_JOB_SIGNALED;
+	else
+		return DRM_DEP_TIMEDOUT_STAT_REQUEUE_JOB;
 }
 
-static void queue_free_job(struct drm_sched_job *sched_job)
+static void job_release(struct drm_dep_job *dep_job);
+
+static const struct drm_dep_job_ops panthor_job_ops = {
+	.release = job_release,
+};
+
+static void panthor_queue_release(struct drm_dep_queue *q)
 {
-	drm_sched_job_cleanup(sched_job);
-	panthor_job_put(sched_job);
+	struct panthor_queue *queue = container_of(q, typeof(*queue), q);
+
+	kfree(queue->name);
+
+	panthor_queue_put_syncwait_obj(queue);
+
+	panthor_kernel_bo_destroy(queue->ringbuf);
+	panthor_kernel_bo_destroy(queue->iface.mem);
+	panthor_kernel_bo_destroy(queue->profiling.slots);
+
+	/* Release the last_fence we were holding, if any. */
+	dma_fence_put(queue->fence_ctx.last_fence);
+
+	drm_dep_queue_release(q);
+	kfree_rcu(queue, q.rcu);
 }
 
-static const struct drm_sched_backend_ops panthor_queue_sched_ops = {
+static const struct drm_dep_queue_ops panthor_queue_ops = {
 	.run_job = queue_run_job,
 	.timedout_job = queue_timedout_job,
-	.free_job = queue_free_job,
+	.release = panthor_queue_release,
 };
 
 static u32 calc_profiling_ringbuf_num_slots(struct panthor_device *ptdev,
@@ -3476,7 +3466,7 @@ static void queue_timeout_work(struct work_struct *work)
 
 	progress = queue_check_job_completion(queue);
 	if (!progress)
-		drm_sched_fault(&queue->scheduler);
+		drm_dep_queue_trigger_timeout(&queue->q);
 }
 
 static struct panthor_queue *
@@ -3484,10 +3474,9 @@ group_create_queue(struct panthor_group *group,
 		   const struct drm_panthor_queue_create *args,
 		   u64 drm_client_id, u32 gid, u32 qid)
 {
-	struct drm_sched_init_args sched_args = {
-		.ops = &panthor_queue_sched_ops,
+	struct drm_dep_queue_init_args q_args = {
+		.ops = &panthor_queue_ops,
 		.submit_wq = group->ptdev->scheduler->wq,
-		.num_rqs = 1,
 		/*
 		 * The credit limit argument tells us the total number of
 		 * instructions across all CS slots in the ringbuffer, with
@@ -3497,9 +3486,10 @@ group_create_queue(struct panthor_group *group,
 		.credit_limit = args->ringbuf_size / sizeof(u64),
 		.timeout = MAX_SCHEDULE_TIMEOUT,
 		.timeout_wq = group->ptdev->reset.wq,
-		.dev = group->ptdev->base.dev,
+		.drm = &group->ptdev->base,
+		.flags = DRM_DEP_QUEUE_FLAGS_JOB_PUT_IRQ_SAFE |
+			DRM_DEP_QUEUE_FLAGS_BYPASS_SUPPORTED,
 	};
-	struct drm_gpu_scheduler *drm_sched;
 	struct panthor_queue *queue;
 	int ret;
 
@@ -3580,14 +3570,9 @@ group_create_queue(struct panthor_group *group,
 		goto err_free_queue;
 	}
 
-	sched_args.name = queue->name;
-
-	ret = drm_sched_init(&queue->scheduler, &sched_args);
-	if (ret)
-		goto err_free_queue;
+	q_args.name = queue->name;
 
-	drm_sched = &queue->scheduler;
-	ret = drm_sched_entity_init(&queue->entity, 0, &drm_sched, 1, NULL);
+	ret = drm_dep_queue_init(&queue->q, &q_args);
 	if (ret)
 		goto err_free_queue;
 
@@ -3907,15 +3892,8 @@ panthor_fdinfo_gather_group_mem_info(struct panthor_file *pfile,
 	xa_unlock(&gpool->xa);
 }
 
-static void job_release(struct kref *ref)
+static void job_cleanup(struct panthor_job *job)
 {
-	struct panthor_job *job = container_of(ref, struct panthor_job, refcount);
-
-	drm_WARN_ON(&job->group->ptdev->base, !list_empty(&job->node));
-
-	if (job->base.s_fence)
-		drm_sched_job_cleanup(&job->base);
-
 	if (dma_fence_was_initialized(job->done_fence))
 		dma_fence_put(job->done_fence);
 	else
@@ -3926,33 +3904,36 @@ static void job_release(struct kref *ref)
 	kfree(job);
 }
 
-struct drm_sched_job *panthor_job_get(struct drm_sched_job *sched_job)
+static void job_release(struct drm_dep_job *dep_job)
 {
-	if (sched_job) {
-		struct panthor_job *job = container_of(sched_job, struct panthor_job, base);
-
-		kref_get(&job->refcount);
-	}
+	struct panthor_job *job = container_of(dep_job, struct panthor_job, base);
 
-	return sched_job;
+	drm_WARN_ON(&job->group->ptdev->base, !list_empty(&job->node));
+	job_cleanup(job);
 }
 
-void panthor_job_put(struct drm_sched_job *sched_job)
+struct drm_dep_job *panthor_job_get(struct drm_dep_job *dep_job)
 {
-	struct panthor_job *job = container_of(sched_job, struct panthor_job, base);
+	if (dep_job)
+		drm_dep_job_get(dep_job);
+
+	return dep_job;
+}
 
-	if (sched_job)
-		kref_put(&job->refcount, job_release);
+void panthor_job_put(struct drm_dep_job *dep_job)
+{
+	if (dep_job)
+		drm_dep_job_put(dep_job);
 }
 
-struct panthor_vm *panthor_job_vm(struct drm_sched_job *sched_job)
+struct panthor_vm *panthor_job_vm(struct drm_dep_job *dep_job)
 {
-	struct panthor_job *job = container_of(sched_job, struct panthor_job, base);
+	struct panthor_job *job = container_of(dep_job, struct panthor_job, base);
 
 	return job->group->vm;
 }
 
-struct drm_sched_job *
+struct drm_dep_job *
 panthor_job_create(struct panthor_file *pfile,
 		   u16 group_handle,
 		   const struct drm_panthor_queue_submit *qsubmit,
@@ -3984,7 +3965,6 @@ panthor_job_create(struct panthor_file *pfile,
 	if (!job)
 		return ERR_PTR(-ENOMEM);
 
-	kref_init(&job->refcount);
 	job->queue_idx = qsubmit->queue_index;
 	job->call_info.size = qsubmit->stream_size;
 	job->call_info.start = qsubmit->stream_addr;
@@ -3994,18 +3974,18 @@ panthor_job_create(struct panthor_file *pfile,
 	job->group = group_from_handle(gpool, group_handle);
 	if (!job->group) {
 		ret = -EINVAL;
-		goto err_put_job;
+		goto err_cleanup_job;
 	}
 
 	if (!group_can_run(job->group)) {
 		ret = -EINVAL;
-		goto err_put_job;
+		goto err_cleanup_job;
 	}
 
 	if (job->queue_idx >= job->group->queue_count ||
 	    !job->group->queues[job->queue_idx]) {
 		ret = -EINVAL;
-		goto err_put_job;
+		goto err_cleanup_job;
 	}
 
 	/* Empty command streams don't need a fence, they'll pick the one from
@@ -4015,7 +3995,7 @@ panthor_job_create(struct panthor_file *pfile,
 		job->done_fence = kzalloc_obj(*job->done_fence);
 		if (!job->done_fence) {
 			ret = -ENOMEM;
-			goto err_put_job;
+			goto err_cleanup_job;
 		}
 	}
 
@@ -4023,27 +4003,30 @@ panthor_job_create(struct panthor_file *pfile,
 	credits = calc_job_credits(job->profiling.mask);
 	if (credits == 0) {
 		ret = -EINVAL;
-		goto err_put_job;
+		goto err_cleanup_job;
 	}
 
-	ret = drm_sched_job_init(&job->base,
-				 &job->group->queues[job->queue_idx]->entity,
-				 credits, job->group, drm_client_id);
+	ret = drm_dep_job_init(&job->base,
+			       &(struct drm_dep_job_init_args){
+					.ops = &panthor_job_ops,
+					.q = &job->group->queues[job->queue_idx]->q,
+					.credits = credits,
+			       });
 	if (ret)
-		goto err_put_job;
+		goto err_cleanup_job;
 
 	return &job->base;
 
-err_put_job:
-	panthor_job_put(&job->base);
+err_cleanup_job:
+	job_cleanup(job);
 	return ERR_PTR(ret);
 }
 
-void panthor_job_update_resvs(struct drm_exec *exec, struct drm_sched_job *sched_job)
+void panthor_job_update_resvs(struct drm_exec *exec, struct drm_dep_job *dep_job)
 {
-	struct panthor_job *job = container_of(sched_job, struct panthor_job, base);
+	struct panthor_job *job = container_of(dep_job, struct panthor_job, base);
 
-	panthor_vm_update_resvs(job->group->vm, exec, &sched_job->s_fence->finished,
+	panthor_vm_update_resvs(job->group->vm, exec, drm_dep_job_finished_fence(dep_job),
 				DMA_RESV_USAGE_BOOKKEEP, DMA_RESV_USAGE_BOOKKEEP);
 }
 
@@ -4171,7 +4154,8 @@ int panthor_sched_init(struct panthor_device *ptdev)
 	 * system is running out of memory.
 	 */
 	sched->heap_alloc_wq = alloc_workqueue("panthor-heap-alloc", WQ_UNBOUND, 0);
-	sched->wq = alloc_workqueue("panthor-csf-sched", WQ_MEM_RECLAIM | WQ_UNBOUND, 0);
+	sched->wq = alloc_workqueue("panthor-csf-sched", WQ_MEM_RECLAIM |
+				    WQ_MEM_WARN_ON_RECLAIM | WQ_UNBOUND, 0);
 	if (!sched->wq || !sched->heap_alloc_wq) {
 		panthor_sched_fini(&ptdev->base, sched);
 		drm_err(&ptdev->base, "Failed to allocate the workqueues");
diff --git a/drivers/gpu/drm/panthor/panthor_sched.h b/drivers/gpu/drm/panthor/panthor_sched.h
index 9a8692de8ade..a7b8e2851f4b 100644
--- a/drivers/gpu/drm/panthor/panthor_sched.h
+++ b/drivers/gpu/drm/panthor/panthor_sched.h
@@ -8,7 +8,7 @@ struct drm_exec;
 struct dma_fence;
 struct drm_file;
 struct drm_gem_object;
-struct drm_sched_job;
+struct drm_dep_job;
 struct drm_memory_stats;
 struct drm_panthor_group_create;
 struct drm_panthor_queue_create;
@@ -27,15 +27,15 @@ int panthor_group_destroy(struct panthor_file *pfile, u32 group_handle);
 int panthor_group_get_state(struct panthor_file *pfile,
 			    struct drm_panthor_group_get_state *get_state);
 
-struct drm_sched_job *
+struct drm_dep_job *
 panthor_job_create(struct panthor_file *pfile,
 		   u16 group_handle,
 		   const struct drm_panthor_queue_submit *qsubmit,
 		   u64 drm_client_id);
-struct drm_sched_job *panthor_job_get(struct drm_sched_job *job);
-struct panthor_vm *panthor_job_vm(struct drm_sched_job *sched_job);
-void panthor_job_put(struct drm_sched_job *job);
-void panthor_job_update_resvs(struct drm_exec *exec, struct drm_sched_job *job);
+struct drm_dep_job *panthor_job_get(struct drm_dep_job *job);
+struct panthor_vm *panthor_job_vm(struct drm_dep_job *dep_job);
+void panthor_job_put(struct drm_dep_job *job);
+void panthor_job_update_resvs(struct drm_exec *exec, struct drm_dep_job *job);
 
 int panthor_group_pool_create(struct panthor_file *pfile);
 void panthor_group_pool_destroy(struct panthor_file *pfile);
-- 
2.34.1