Skip to contentSkip to conversation

drm/amdkfd: Move the process suspend and resume out of full access

PATCH Superseded Emily Deng 3 participants 8 messages May 27, 2025 – Jun 4, 2025

Subsystems (3)

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore

Emily Deng

author
#0 lore raw

PATCH v2 1/1 drm/amdkfd: Move the process suspend and resume out of full access

For the suspend and resume process, exclusive access is not required. Therefore, it can be moved out of the full access section to reduce the duration of exclusive access.

---
 drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c | 16 +++++++++
 drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h | 13 +++++++
 drivers/gpu/drm/amd/amdgpu/amdgpu_device.c | 12 +++++--
 drivers/gpu/drm/amd/amdkfd/kfd_device.c    | 40 +++++++++++++++++-----
 4 files changed, 70 insertions(+), 11 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c +16 -0
index 4cec3a873995..ba07e9c6619d 100644
@@ -264,6 +264,22 @@ int amdgpu_amdkfd_resume(struct amdgpu_device *adev, bool run_pm)
 	return r;
 }
 
+void amdgpu_amdkfd_suspend_process(struct amdgpu_device *adev, bool run_pm)
+{
+	if (adev->kfd.dev)
+		kgd2kfd_suspend_process(adev->kfd.dev, run_pm);
+}
+
+int amdgpu_amdkfd_resume_process(struct amdgpu_device *adev, bool run_pm)
+{
+	int r = 0;
+
+	if (adev->kfd.dev)
+		r = kgd2kfd_resume_process(adev->kfd.dev, run_pm);
+
+	return r;
+}
+
 int amdgpu_amdkfd_pre_reset(struct amdgpu_device *adev,
 			    struct amdgpu_reset_context *reset_context)
 {
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +13 -0
index b6ca41859b53..841ae8b75ab1 100644
@@ -156,6 +156,8 @@ void amdgpu_amdkfd_fini(void);
 
 void amdgpu_amdkfd_suspend(struct amdgpu_device *adev, bool run_pm);
 int amdgpu_amdkfd_resume(struct amdgpu_device *adev, bool run_pm);
+void amdgpu_amdkfd_suspend_process(struct amdgpu_device *adev, bool run_pm);
+int amdgpu_amdkfd_resume_process(struct amdgpu_device *adev, bool run_pm);
 void amdgpu_amdkfd_interrupt(struct amdgpu_device *adev,
 			const void *ih_ring_entry);
 void amdgpu_amdkfd_device_probe(struct amdgpu_device *adev);
@@ -413,6 +415,8 @@ bool kgd2kfd_device_init(struct kfd_dev *kfd,
 void kgd2kfd_device_exit(struct kfd_dev *kfd);
 void kgd2kfd_suspend(struct kfd_dev *kfd, bool run_pm);
 int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm);
+void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool run_pm);
+int kgd2kfd_resume_process(struct kfd_dev *kfd, bool run_pm);
 int kgd2kfd_pre_reset(struct kfd_dev *kfd,
 		      struct amdgpu_reset_context *reset_context);
 int kgd2kfd_post_reset(struct kfd_dev *kfd);
@@ -463,6 +467,15 @@ static inline int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm)
 	return 0;
 }
 
+static inline void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool run_pm)
+{
+}
+
+static inline int kgd2kfd_resume_process(struct kfd_dev *kfd, bool run_pm)
+{
+	return 0;
+}
+
 static inline int kgd2kfd_pre_reset(struct kfd_dev *kfd,
 				    struct amdgpu_reset_context *reset_context)
 {
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +10 -2
index 625c416c7d45..6e29f8bd54bb 100644
@@ -5080,7 +5080,7 @@ int amdgpu_device_suspend(struct drm_device *dev, bool notify_clients)
 	amdgpu_device_ip_suspend_phase1(adev);
 
 	if (!adev->in_s0ix) {
-		amdgpu_amdkfd_suspend(adev, adev->in_runpm);
+		amdgpu_amdkfd_suspend(adev, !amdgpu_sriov_runtime(adev) || adev->in_runpm);
 		amdgpu_userq_suspend(adev);
 	}
 
@@ -5097,6 +5097,9 @@ int amdgpu_device_suspend(struct drm_device *dev, bool notify_clients)
 	if (amdgpu_sriov_vf(adev))
 		amdgpu_virt_release_full_gpu(adev, false);
 
+	if (!adev->in_s0ix)
+		amdgpu_amdkfd_suspend_process(adev, adev->in_runpm);
+
 	r = amdgpu_dpm_notify_rlc_state(adev, false);
 	if (r)
 		return r;
@@ -5178,7 +5181,7 @@ int amdgpu_device_resume(struct drm_device *dev, bool notify_clients)
 	}
 
 	if (!adev->in_s0ix) {
-		r = amdgpu_amdkfd_resume(adev, adev->in_runpm);
+		r = amdgpu_amdkfd_resume(adev, !amdgpu_sriov_runtime(adev) || adev->in_runpm);
 		if (r)
 			goto exit;
 
@@ -5199,6 +5202,11 @@ int amdgpu_device_resume(struct drm_device *dev, bool notify_clients)
 		amdgpu_virt_release_full_gpu(adev, true);
 	}
 
+	if (!adev->in_s0ix) {
+		r = amdgpu_amdkfd_resume_process(adev, adev->in_runpm);
+		if (r)
+			goto exit;
+	}
 	if (r)
 		return r;
 
drivers/gpu/drm/amd/amdkfd/kfd_device.c +31 -9
index bf0854bd5555..22c6ef7c42b6 100644
@@ -1027,15 +1027,7 @@ void kgd2kfd_suspend(struct kfd_dev *kfd, bool run_pm)
 	if (!kfd->init_complete)
 		return;
 
-	/* for runtime suspend, skip locking kfd */
-	if (!run_pm) {
-		mutex_lock(&kfd_processes_mutex);
-		/* For first KFD device suspend all the KFD processes */
-		if (++kfd_locked == 1)
-			kfd_suspend_all_processes();
-		mutex_unlock(&kfd_processes_mutex);
-	}
-
+	kgd2kfd_suspend_process(kfd, run_pm);
 	for (i = 0; i < kfd->num_nodes; i++) {
 		node = kfd->nodes[i];
 		node->dqm->ops.stop(node->dqm);
@@ -1055,6 +1047,36 @@ int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm)
 			return ret;
 	}
 
+	ret = kgd2kfd_resume_process(kfd, run_pm);
+
+	return ret;
+}
+
+void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool run_pm)
+{
+	struct kfd_node *node;
+	int i;
+
+	if (!kfd->init_complete)
+		return;
+
+	/* for runtime suspend, skip locking kfd */
+	if (!run_pm) {
+		mutex_lock(&kfd_processes_mutex);
+		/* For first KFD device suspend all the KFD processes */
+		if (++kfd_locked == 1)
+			kfd_suspend_all_processes();
+		mutex_unlock(&kfd_processes_mutex);
+	}
+}
+
+int kgd2kfd_resume_process(struct kfd_dev *kfd, bool run_pm)
+{
+	int ret, i;
+
+	if (!kfd->init_complete)
+		return 0;
+
 	/* for runtime resume, skip unlocking kfd */
 	if (!run_pm) {
 		mutex_lock(&kfd_processes_mutex);
Signature · 1 line
2.34.1
#1 lore raw

[AMD Official Use Only - AMD Internal Distribution Only]

Quoted 194 lines

-----Original Message-----
From: Emily Deng <[email protected]>
Sent: Tuesday, May 27, 2025 6:50 PM
To: [email protected]
Cc: Deng, Emily <[email protected]>
Subject: [PATCH v2] drm/amdkfd: Move the process suspend and resume out of full access

For the suspend and resume process, exclusive access is not required. Therefore, it can be moved out of the full access section to reduce the duration of exclusive access.

---

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c | 16 +++++++++
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h | 13 +++++++
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c | 12 +++++--
drivers/gpu/drm/amd/amdkfd/kfd_device.c    | 40 +++++++++++++++++-----
4 files changed, 70 insertions(+), 11 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c +15 -0
index 4cec3a873995..ba07e9c6619d 100644
@@ -264,6 +264,22 @@ int amdgpu_amdkfd_resume(struct amdgpu_device *adev,
 bool run_pm)
      return r;
 }
 
+void amdgpu_amdkfd_suspend_process(struct amdgpu_device *adev, bool
+run_pm) {
+      if (adev->kfd.dev)
+              kgd2kfd_suspend_process(adev->kfd.dev, run_pm); }
+
+int amdgpu_amdkfd_resume_process(struct amdgpu_device *adev, bool
+run_pm) {
+      int r = 0;
+
+      if (adev->kfd.dev)
+              r = kgd2kfd_resume_process(adev->kfd.dev, run_pm);
+
+      return r;
+}
+
 int amdgpu_amdkfd_pre_reset(struct amdgpu_device *adev,
                          struct amdgpu_reset_context *reset_context)  { diff --git

a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h
b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h
index b6ca41859b53..841ae8b75ab1 100644

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +0 -0
@@ -156,6 +156,8 @@ void amdgpu_amdkfd_fini(void);
 

void amdgpu_amdkfd_suspend(struct amdgpu_device *adev, bool run_pm); int amdgpu_amdkfd_resume(struct amdgpu_device *adev, bool run_pm);

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +3 -0
+void amdgpu_amdkfd_suspend_process(struct amdgpu_device *adev, bool
+run_pm); int amdgpu_amdkfd_resume_process(struct amdgpu_device *adev,
+bool run_pm);

void amdgpu_amdkfd_interrupt(struct amdgpu_device *adev,

                      const void *ih_ring_entry);

void amdgpu_amdkfd_device_probe(struct amdgpu_device *adev); @@ -413,6 +415,8 @@ bool kgd2kfd_device_init(struct kfd_dev *kfd, void kgd2kfd_device_exit(struct kfd_dev *kfd); void kgd2kfd_suspend(struct kfd_dev *kfd, bool run_pm); int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm);

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +2 -0
+void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool run_pm); int
+kgd2kfd_resume_process(struct kfd_dev *kfd, bool run_pm);

int kgd2kfd_pre_reset(struct kfd_dev *kfd,
struct amdgpu_reset_context *reset_context); int
kgd2kfd_post_reset(struct kfd_dev *kfd); @@ -463,6 +467,15 @@ static inline int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm)

      return 0;
}
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +8 -0
+static inline void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool
+run_pm) { }
+
+static inline int kgd2kfd_resume_process(struct kfd_dev *kfd, bool
+run_pm) {
+      return 0;
+}
+

static inline int kgd2kfd_pre_reset(struct kfd_dev *kfd,
struct amdgpu_reset_context *reset_context) { diff --
git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
index 625c416c7d45..6e29f8bd54bb 100644

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -1
@@ -5080,7 +5080,7 @@ int amdgpu_device_suspend(struct drm_device *dev, bool
 notify_clients)
      amdgpu_device_ip_suspend_phase1(adev);
 
      if (!adev->in_s0ix) {
-              amdgpu_amdkfd_suspend(adev, adev->in_runpm);
+              amdgpu_amdkfd_suspend(adev, !amdgpu_sriov_runtime(adev) ||
+adev->in_runpm);
              amdgpu_userq_suspend(adev);
      }
@@ -5097,6 +5097,9 @@ int amdgpu_device_suspend(struct drm_device *dev, bool
 notify_clients)
      if (amdgpu_sriov_vf(adev))
              amdgpu_virt_release_full_gpu(adev, false);
 
+      if (!adev->in_s0ix)
+              amdgpu_amdkfd_suspend_process(adev, adev->in_runpm);
+
      r = amdgpu_dpm_notify_rlc_state(adev, false);
      if (r)
              return r;
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +7 -1
@@ -5178,7 +5181,7 @@ int amdgpu_device_resume(struct drm_device *dev, bool
 notify_clients)
      }
 
      if (!adev->in_s0ix) {
-              r = amdgpu_amdkfd_resume(adev, adev->in_runpm);
+              r = amdgpu_amdkfd_resume(adev, !amdgpu_sriov_runtime(adev) ||
+adev->in_runpm);
              if (r)
                      goto exit;
@@ -5199,6 +5202,11 @@ int amdgpu_device_resume(struct drm_device *dev, bool
 notify_clients)
              amdgpu_virt_release_full_gpu(adev, true);
      }
 
+      if (!adev->in_s0ix) {
+              r = amdgpu_amdkfd_resume_process(adev, adev->in_runpm);
+              if (r)
+                      goto exit;
+      }
      if (r)
              return r;
drivers/gpu/drm/amd/amdkfd/kfd_device.c +29 -10
index bf0854bd5555..22c6ef7c42b6 100644
@@ -1027,15 +1027,7 @@ void kgd2kfd_suspend(struct kfd_dev *kfd, bool run_pm)
      if (!kfd->init_complete)
              return;
 
-      /* for runtime suspend, skip locking kfd */
-      if (!run_pm) {
-              mutex_lock(&kfd_processes_mutex);
-              /* For first KFD device suspend all the KFD processes */
-              if (++kfd_locked == 1)
-                      kfd_suspend_all_processes();
-              mutex_unlock(&kfd_processes_mutex);
-      }
-
+      kgd2kfd_suspend_process(kfd, run_pm);
      for (i = 0; i < kfd->num_nodes; i++) {
              node = kfd->nodes[i];
              node->dqm->ops.stop(node->dqm);
@@ -1055,6 +1047,36 @@ int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm)
                      return ret;
      }
 
+      ret = kgd2kfd_resume_process(kfd, run_pm);
+
+      return ret;
+}
+
+void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool run_pm) {
+      struct kfd_node *node;
+      int i;
+
+      if (!kfd->init_complete)
+              return;
+
+      /* for runtime suspend, skip locking kfd */
+      if (!run_pm) {
+              mutex_lock(&kfd_processes_mutex);
+              /* For first KFD device suspend all the KFD processes */
+              if (++kfd_locked == 1)
+                      kfd_suspend_all_processes();
+              mutex_unlock(&kfd_processes_mutex);
+      }
+}
+
+int kgd2kfd_resume_process(struct kfd_dev *kfd, bool run_pm) {
+      int ret, i;
+
+      if (!kfd->init_complete)
+              return 0;
+
      /* for runtime resume, skip unlocking kfd */
      if (!run_pm) {
              mutex_lock(&kfd_processes_mutex);
--

2.34.1

#2 lore raw

[AMD Official Use Only - AMD Internal Distribution Only]

Ping......

Emily Deng
Best Wishes

Quoted 214 lines

-----Original Message-----
From: Deng, Emily <[email protected]>
Sent: Wednesday, May 28, 2025 2:20 PM
To: Deng, Emily <[email protected]>; [email protected]
Cc: Zhang, Owen(SRDC) <[email protected]>
Subject: RE: [PATCH v2] drm/amdkfd: Move the process suspend and resume out of full access

[AMD Official Use Only - AMD Internal Distribution Only]

drivers/gpu/drm/amd/amdkfd/kfd_device.c void kgd2kfd_suspend(struct kfd_dev *kfd, bool

Quoted 149 lines

-----Original Message-----
From: Emily Deng <[email protected]>
Sent: Tuesday, May 27, 2025 6:50 PM
To: [email protected]
Cc: Deng, Emily <[email protected]>
Subject: [PATCH v2] drm/amdkfd: Move the process suspend and resume out of full access

For the suspend and resume process, exclusive access is not required. Therefore, it can be moved out of the full access section to reduce the duration of exclusive access.

---

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c | 16 +++++++++
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h | 13 +++++++
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c | 12 +++++--
drivers/gpu/drm/amd/amdkfd/kfd_device.c    | 40 +++++++++++++++++-----
4 files changed, 70 insertions(+), 11 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c +15 -0
index 4cec3a873995..ba07e9c6619d 100644
@@ -264,6 +264,22 @@ int amdgpu_amdkfd_resume(struct amdgpu_device
 *adev, bool run_pm)
      return r;
 }
 
+void amdgpu_amdkfd_suspend_process(struct amdgpu_device *adev, bool
+run_pm) {
+      if (adev->kfd.dev)
+              kgd2kfd_suspend_process(adev->kfd.dev, run_pm); }
+
+int amdgpu_amdkfd_resume_process(struct amdgpu_device *adev, bool
+run_pm) {
+      int r = 0;
+
+      if (adev->kfd.dev)
+              r = kgd2kfd_resume_process(adev->kfd.dev, run_pm);
+
+      return r;
+}
+
 int amdgpu_amdkfd_pre_reset(struct amdgpu_device *adev,
                          struct amdgpu_reset_context *reset_context)

{ diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h index b6ca41859b53..841ae8b75ab1 100644

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +3 -0
@@ -156,6 +156,8 @@ void amdgpu_amdkfd_fini(void);
 
 void amdgpu_amdkfd_suspend(struct amdgpu_device *adev, bool run_pm);
 int amdgpu_amdkfd_resume(struct amdgpu_device *adev, bool run_pm);
+void amdgpu_amdkfd_suspend_process(struct amdgpu_device *adev, bool
+run_pm); int amdgpu_amdkfd_resume_process(struct amdgpu_device *adev,
+bool run_pm);
 void amdgpu_amdkfd_interrupt(struct amdgpu_device *adev,
                      const void *ih_ring_entry); void

amdgpu_amdkfd_device_probe(struct amdgpu_device *adev); @@ -413,6 +415,8 @@ bool kgd2kfd_device_init(struct kfd_dev *kfd, void kgd2kfd_device_exit(struct kfd_dev *kfd); void kgd2kfd_suspend(struct kfd_dev *kfd, bool run_pm); int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm);

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +2 -0
+void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool run_pm); int
+kgd2kfd_resume_process(struct kfd_dev *kfd, bool run_pm);

int kgd2kfd_pre_reset(struct kfd_dev *kfd,
struct amdgpu_reset_context *reset_context); int
kgd2kfd_post_reset(struct kfd_dev *kfd); @@ -463,6 +467,15 @@ static inline int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm)

      return 0;
}
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +8 -0
+static inline void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool
+run_pm) { }
+
+static inline int kgd2kfd_resume_process(struct kfd_dev *kfd, bool
+run_pm) {
+      return 0;
+}
+

static inline int kgd2kfd_pre_reset(struct kfd_dev *kfd,
struct amdgpu_reset_context
*reset_context) { diff -- git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
index 625c416c7d45..6e29f8bd54bb 100644

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
@@ -5080,7 +5080,7 @@ int amdgpu_device_suspend(struct drm_device *dev,

bool
notify_clients)

      amdgpu_device_ip_suspend_phase1(adev);

      if (!adev->in_s0ix) {
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -1
-              amdgpu_amdkfd_suspend(adev, adev->in_runpm);
+              amdgpu_amdkfd_suspend(adev, !amdgpu_sriov_runtime(adev)
+ ||
+adev->in_runpm);
              amdgpu_userq_suspend(adev);
      }
@@ -5097,6 +5097,9 @@ int amdgpu_device_suspend(struct drm_device *dev,

bool
notify_clients)

      if (amdgpu_sriov_vf(adev))
              amdgpu_virt_release_full_gpu(adev, false);
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -0
+      if (!adev->in_s0ix)
+              amdgpu_amdkfd_suspend_process(adev, adev->in_runpm);
+
      r = amdgpu_dpm_notify_rlc_state(adev, false);
      if (r)
              return r;
@@ -5178,7 +5181,7 @@ int amdgpu_device_resume(struct drm_device *dev,

bool
notify_clients)

      }

      if (!adev->in_s0ix) {
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -1
-              r = amdgpu_amdkfd_resume(adev, adev->in_runpm);
+              r = amdgpu_amdkfd_resume(adev,
+ !amdgpu_sriov_runtime(adev) ||
+adev->in_runpm);
              if (r)
                      goto exit;
@@ -5199,6 +5202,11 @@ int amdgpu_device_resume(struct drm_device *dev,

bool
notify_clients)

              amdgpu_virt_release_full_gpu(adev, true);
      }
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -0
+      if (!adev->in_s0ix) {
+              r = amdgpu_amdkfd_resume_process(adev, adev->in_runpm);
+              if (r)
+                      goto exit;
+      }
      if (r)
              return r;
drivers/gpu/drm/amd/amdkfd/kfd_device.c +0 -0
index bf0854bd5555..22c6ef7c42b6 100644
@@ -1027,15 +1027,7 @@ void kgd2kfd_suspend(struct kfd_dev *kfd, bool

run_pm)

Quoted 53 lines
drivers/gpu/drm/amd/amdkfd/kfd_device.c +1 -9
      if (!kfd->init_complete)
              return;
 
-      /* for runtime suspend, skip locking kfd */
-      if (!run_pm) {
-              mutex_lock(&kfd_processes_mutex);
-              /* For first KFD device suspend all the KFD processes */
-              if (++kfd_locked == 1)
-                      kfd_suspend_all_processes();
-              mutex_unlock(&kfd_processes_mutex);
-      }
-
+      kgd2kfd_suspend_process(kfd, run_pm);
      for (i = 0; i < kfd->num_nodes; i++) {
              node = kfd->nodes[i];
              node->dqm->ops.stop(node->dqm); @@ -1055,6 +1047,36 @@

int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm)

                      return ret;
      }
drivers/gpu/drm/amd/amdkfd/kfd_device.c +28 -1
+      ret = kgd2kfd_resume_process(kfd, run_pm);
+
+      return ret;
+}
+
+void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool run_pm) {
+      struct kfd_node *node;
+      int i;
+
+      if (!kfd->init_complete)
+              return;
+
+      /* for runtime suspend, skip locking kfd */
+      if (!run_pm) {
+              mutex_lock(&kfd_processes_mutex);
+              /* For first KFD device suspend all the KFD processes */
+              if (++kfd_locked == 1)
+                      kfd_suspend_all_processes();
+              mutex_unlock(&kfd_processes_mutex);
+      }
+}
+
+int kgd2kfd_resume_process(struct kfd_dev *kfd, bool run_pm) {
+      int ret, i;
+
+      if (!kfd->init_complete)
+              return 0;
+
      /* for runtime resume, skip unlocking kfd */
      if (!run_pm) {
              mutex_lock(&kfd_processes_mutex);
--

2.34.1

#3 lore raw

[AMD Official Use Only - AMD Internal Distribution Only]

Hi Team, @[email protected]

Can you pls review and provide your inputs? Thanks for support!

Rgds/Owen

-----Original Message-----
From: Deng, Emily <[email protected]>
Sent: Friday, May 30, 2025 9:39 AM
To: [email protected]
Cc: Zhang, Owen(SRDC) <[email protected]>
Subject: RE: [PATCH v2] drm/amdkfd: Move the process suspend and resume out of full access

[AMD Official Use Only - AMD Internal Distribution Only]

Ping......

Emily Deng
Best Wishes

Quoted 214 lines

-----Original Message-----
From: Deng, Emily <[email protected]>
Sent: Wednesday, May 28, 2025 2:20 PM
To: Deng, Emily <[email protected]>; [email protected]
Cc: Zhang, Owen(SRDC) <[email protected]>
Subject: RE: [PATCH v2] drm/amdkfd: Move the process suspend and resume out of full access

[AMD Official Use Only - AMD Internal Distribution Only]

drivers/gpu/drm/amd/amdkfd/kfd_device.c void kgd2kfd_suspend(struct kfd_dev *kfd, bool

Quoted 149 lines

-----Original Message-----
From: Emily Deng <[email protected]>
Sent: Tuesday, May 27, 2025 6:50 PM
To: [email protected]
Cc: Deng, Emily <[email protected]>
Subject: [PATCH v2] drm/amdkfd: Move the process suspend and resume out of full access

For the suspend and resume process, exclusive access is not required. Therefore, it can be moved out of the full access section to reduce the duration of exclusive access.

---

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c | 16 +++++++++
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h | 13 +++++++
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c | 12 +++++--
drivers/gpu/drm/amd/amdkfd/kfd_device.c    | 40 +++++++++++++++++-----
4 files changed, 70 insertions(+), 11 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c +15 -0
index 4cec3a873995..ba07e9c6619d 100644
@@ -264,6 +264,22 @@ int amdgpu_amdkfd_resume(struct amdgpu_device
 *adev, bool run_pm)
      return r;
 }
 
+void amdgpu_amdkfd_suspend_process(struct amdgpu_device *adev, bool
+run_pm) {
+      if (adev->kfd.dev)
+              kgd2kfd_suspend_process(adev->kfd.dev, run_pm); }
+
+int amdgpu_amdkfd_resume_process(struct amdgpu_device *adev, bool
+run_pm) {
+      int r = 0;
+
+      if (adev->kfd.dev)
+              r = kgd2kfd_resume_process(adev->kfd.dev, run_pm);
+
+      return r;
+}
+
 int amdgpu_amdkfd_pre_reset(struct amdgpu_device *adev,
                          struct amdgpu_reset_context *reset_context)

{ diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h index b6ca41859b53..841ae8b75ab1 100644

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +3 -0
@@ -156,6 +156,8 @@ void amdgpu_amdkfd_fini(void);
 
 void amdgpu_amdkfd_suspend(struct amdgpu_device *adev, bool run_pm);
 int amdgpu_amdkfd_resume(struct amdgpu_device *adev, bool run_pm);
+void amdgpu_amdkfd_suspend_process(struct amdgpu_device *adev, bool
+run_pm); int amdgpu_amdkfd_resume_process(struct amdgpu_device *adev,
+bool run_pm);
 void amdgpu_amdkfd_interrupt(struct amdgpu_device *adev,
                      const void *ih_ring_entry); void

amdgpu_amdkfd_device_probe(struct amdgpu_device *adev); @@ -413,6 +415,8 @@ bool kgd2kfd_device_init(struct kfd_dev *kfd, void kgd2kfd_device_exit(struct kfd_dev *kfd); void kgd2kfd_suspend(struct kfd_dev *kfd, bool run_pm); int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm);

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +2 -0
+void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool run_pm); int
+kgd2kfd_resume_process(struct kfd_dev *kfd, bool run_pm);

int kgd2kfd_pre_reset(struct kfd_dev *kfd,
struct amdgpu_reset_context *reset_context); int
kgd2kfd_post_reset(struct kfd_dev *kfd); @@ -463,6 +467,15 @@ static inline int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm)

      return 0;
}
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +8 -0
+static inline void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool
+run_pm) { }
+
+static inline int kgd2kfd_resume_process(struct kfd_dev *kfd, bool
+run_pm) {
+      return 0;
+}
+

static inline int kgd2kfd_pre_reset(struct kfd_dev *kfd,
struct amdgpu_reset_context
*reset_context) { diff -- git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
index 625c416c7d45..6e29f8bd54bb 100644

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +6 -1
@@ -5080,7 +5080,7 @@ int amdgpu_device_suspend(struct drm_device
 *dev, bool
 notify_clients)
      amdgpu_device_ip_suspend_phase1(adev);
 
      if (!adev->in_s0ix) {
-              amdgpu_amdkfd_suspend(adev, adev->in_runpm);
+              amdgpu_amdkfd_suspend(adev, !amdgpu_sriov_runtime(adev)
+ ||
+adev->in_runpm);
              amdgpu_userq_suspend(adev);
      }
@@ -5097,6 +5097,9 @@ int amdgpu_device_suspend(struct drm_device
 *dev, bool
 notify_clients)
      if (amdgpu_sriov_vf(adev))
              amdgpu_virt_release_full_gpu(adev, false);
 
+      if (!adev->in_s0ix)
+              amdgpu_amdkfd_suspend_process(adev, adev->in_runpm);
+
      r = amdgpu_dpm_notify_rlc_state(adev, false);
      if (r)
              return r;
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
@@ -5178,7 +5181,7 @@ int amdgpu_device_resume(struct drm_device *dev,

bool
notify_clients)

      }

      if (!adev->in_s0ix) {
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +8 -1
-              r = amdgpu_amdkfd_resume(adev, adev->in_runpm);
+              r = amdgpu_amdkfd_resume(adev,
+ !amdgpu_sriov_runtime(adev) ||
+adev->in_runpm);
              if (r)
                      goto exit;
@@ -5199,6 +5202,11 @@ int amdgpu_device_resume(struct drm_device
 *dev, bool
 notify_clients)
              amdgpu_virt_release_full_gpu(adev, true);
      }
 
+      if (!adev->in_s0ix) {
+              r = amdgpu_amdkfd_resume_process(adev, adev->in_runpm);
+              if (r)
+                      goto exit;
+      }
      if (r)
              return r;
drivers/gpu/drm/amd/amdkfd/kfd_device.c +0 -0
index bf0854bd5555..22c6ef7c42b6 100644
@@ -1027,15 +1027,7 @@ void kgd2kfd_suspend(struct kfd_dev *kfd, bool

run_pm)

Quoted 53 lines
drivers/gpu/drm/amd/amdkfd/kfd_device.c +1 -9
      if (!kfd->init_complete)
              return;
 
-      /* for runtime suspend, skip locking kfd */
-      if (!run_pm) {
-              mutex_lock(&kfd_processes_mutex);
-              /* For first KFD device suspend all the KFD processes */
-              if (++kfd_locked == 1)
-                      kfd_suspend_all_processes();
-              mutex_unlock(&kfd_processes_mutex);
-      }
-
+      kgd2kfd_suspend_process(kfd, run_pm);
      for (i = 0; i < kfd->num_nodes; i++) {
              node = kfd->nodes[i];
              node->dqm->ops.stop(node->dqm); @@ -1055,6 +1047,36 @@

int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm)

                      return ret;
      }
drivers/gpu/drm/amd/amdkfd/kfd_device.c +28 -1
+      ret = kgd2kfd_resume_process(kfd, run_pm);
+
+      return ret;
+}
+
+void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool run_pm) {
+      struct kfd_node *node;
+      int i;
+
+      if (!kfd->init_complete)
+              return;
+
+      /* for runtime suspend, skip locking kfd */
+      if (!run_pm) {
+              mutex_lock(&kfd_processes_mutex);
+              /* For first KFD device suspend all the KFD processes */
+              if (++kfd_locked == 1)
+                      kfd_suspend_all_processes();
+              mutex_unlock(&kfd_processes_mutex);
+      }
+}
+
+int kgd2kfd_resume_process(struct kfd_dev *kfd, bool run_pm) {
+      int ret, i;
+
+      if (!kfd->init_complete)
+              return 0;
+
      /* for runtime resume, skip unlocking kfd */
      if (!run_pm) {
              mutex_lock(&kfd_processes_mutex);
--

2.34.1

#4 lore raw

[AMD Official Use Only - AMD Internal Distribution Only]

Hi Christian and Horace,
Could you help to review this?

Emily Deng
Best Wishes

Quoted 249 lines

-----Original Message-----
From: Zhang, Owen(SRDC) <[email protected]>
Sent: Friday, May 30, 2025 5:50 PM
To: Deng, Emily <[email protected]>; [email protected]
Subject: RE: [PATCH v2] drm/amdkfd: Move the process suspend and resume out of full access

[AMD Official Use Only - AMD Internal Distribution Only]

Hi Team, @[email protected]

Can you pls review and provide your inputs? Thanks for support!

Rgds/Owen

-----Original Message-----
From: Deng, Emily <[email protected]>
Sent: Friday, May 30, 2025 9:39 AM
To: [email protected]
Cc: Zhang, Owen(SRDC) <[email protected]>
Subject: RE: [PATCH v2] drm/amdkfd: Move the process suspend and resume out of full access

[AMD Official Use Only - AMD Internal Distribution Only]

Ping......

Emily Deng
Best Wishes

Quoted 214 lines

-----Original Message-----
From: Deng, Emily <[email protected]>
Sent: Wednesday, May 28, 2025 2:20 PM
To: Deng, Emily <[email protected]>; [email protected]
Cc: Zhang, Owen(SRDC) <[email protected]>
Subject: RE: [PATCH v2] drm/amdkfd: Move the process suspend and resume out of full access

[AMD Official Use Only - AMD Internal Distribution Only]

drivers/gpu/drm/amd/amdkfd/kfd_device.c void kgd2kfd_suspend(struct kfd_dev *kfd, bool

Quoted 149 lines

-----Original Message-----
From: Emily Deng <[email protected]>
Sent: Tuesday, May 27, 2025 6:50 PM
To: [email protected]
Cc: Deng, Emily <[email protected]>
Subject: [PATCH v2] drm/amdkfd: Move the process suspend and resume out of full access

For the suspend and resume process, exclusive access is not required. Therefore, it can be moved out of the full access section to reduce the duration of exclusive access.

---

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c | 16 +++++++++
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h | 13 +++++++
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c | 12 +++++--
drivers/gpu/drm/amd/amdkfd/kfd_device.c    | 40 +++++++++++++++++-----
4 files changed, 70 insertions(+), 11 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c +15 -0
index 4cec3a873995..ba07e9c6619d 100644
@@ -264,6 +264,22 @@ int amdgpu_amdkfd_resume(struct amdgpu_device
 *adev, bool run_pm)
      return r;
 }
 
+void amdgpu_amdkfd_suspend_process(struct amdgpu_device *adev, bool
+run_pm) {
+      if (adev->kfd.dev)
+              kgd2kfd_suspend_process(adev->kfd.dev, run_pm); }
+
+int amdgpu_amdkfd_resume_process(struct amdgpu_device *adev, bool
+run_pm) {
+      int r = 0;
+
+      if (adev->kfd.dev)
+              r = kgd2kfd_resume_process(adev->kfd.dev, run_pm);
+
+      return r;
+}
+
 int amdgpu_amdkfd_pre_reset(struct amdgpu_device *adev,
                          struct amdgpu_reset_context *reset_context)

{ diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h index b6ca41859b53..841ae8b75ab1 100644

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +3 -0
@@ -156,6 +156,8 @@ void amdgpu_amdkfd_fini(void);
 
 void amdgpu_amdkfd_suspend(struct amdgpu_device *adev, bool run_pm);
 int amdgpu_amdkfd_resume(struct amdgpu_device *adev, bool run_pm);
+void amdgpu_amdkfd_suspend_process(struct amdgpu_device *adev, bool
+run_pm); int amdgpu_amdkfd_resume_process(struct amdgpu_device *adev,
+bool run_pm);
 void amdgpu_amdkfd_interrupt(struct amdgpu_device *adev,
                      const void *ih_ring_entry); void

amdgpu_amdkfd_device_probe(struct amdgpu_device *adev); @@ -413,6 +415,8 @@ bool kgd2kfd_device_init(struct kfd_dev *kfd, void kgd2kfd_device_exit(struct kfd_dev *kfd); void kgd2kfd_suspend(struct kfd_dev *kfd, bool run_pm); int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm);

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +2 -0
+void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool run_pm); int
+kgd2kfd_resume_process(struct kfd_dev *kfd, bool run_pm);

int kgd2kfd_pre_reset(struct kfd_dev *kfd,
struct amdgpu_reset_context *reset_context); int
kgd2kfd_post_reset(struct kfd_dev *kfd); @@ -463,6 +467,15 @@ static inline int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm)

      return 0;
}
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +8 -0
+static inline void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool
+run_pm) { }
+
+static inline int kgd2kfd_resume_process(struct kfd_dev *kfd, bool
+run_pm) {
+      return 0;
+}
+

static inline int kgd2kfd_pre_reset(struct kfd_dev *kfd,
struct amdgpu_reset_context
*reset_context) { diff -- git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
index 625c416c7d45..6e29f8bd54bb 100644

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +6 -1
@@ -5080,7 +5080,7 @@ int amdgpu_device_suspend(struct drm_device
 *dev, bool
 notify_clients)
      amdgpu_device_ip_suspend_phase1(adev);
 
      if (!adev->in_s0ix) {
-              amdgpu_amdkfd_suspend(adev, adev->in_runpm);
+              amdgpu_amdkfd_suspend(adev, !amdgpu_sriov_runtime(adev)
+ ||
+adev->in_runpm);
              amdgpu_userq_suspend(adev);
      }
@@ -5097,6 +5097,9 @@ int amdgpu_device_suspend(struct drm_device
 *dev, bool
 notify_clients)
      if (amdgpu_sriov_vf(adev))
              amdgpu_virt_release_full_gpu(adev, false);
 
+      if (!adev->in_s0ix)
+              amdgpu_amdkfd_suspend_process(adev, adev->in_runpm);
+
      r = amdgpu_dpm_notify_rlc_state(adev, false);
      if (r)
              return r;
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
@@ -5178,7 +5181,7 @@ int amdgpu_device_resume(struct drm_device *dev,

bool
notify_clients)

      }

      if (!adev->in_s0ix) {
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +8 -1
-              r = amdgpu_amdkfd_resume(adev, adev->in_runpm);
+              r = amdgpu_amdkfd_resume(adev,
+ !amdgpu_sriov_runtime(adev) ||
+adev->in_runpm);
              if (r)
                      goto exit;
@@ -5199,6 +5202,11 @@ int amdgpu_device_resume(struct drm_device
 *dev, bool
 notify_clients)
              amdgpu_virt_release_full_gpu(adev, true);
      }
 
+      if (!adev->in_s0ix) {
+              r = amdgpu_amdkfd_resume_process(adev, adev->in_runpm);
+              if (r)
+                      goto exit;
+      }
      if (r)
              return r;
drivers/gpu/drm/amd/amdkfd/kfd_device.c +0 -0
index bf0854bd5555..22c6ef7c42b6 100644
@@ -1027,15 +1027,7 @@ void kgd2kfd_suspend(struct kfd_dev *kfd, bool

run_pm)

Quoted 53 lines
drivers/gpu/drm/amd/amdkfd/kfd_device.c +1 -9
      if (!kfd->init_complete)
              return;
 
-      /* for runtime suspend, skip locking kfd */
-      if (!run_pm) {
-              mutex_lock(&kfd_processes_mutex);
-              /* For first KFD device suspend all the KFD processes */
-              if (++kfd_locked == 1)
-                      kfd_suspend_all_processes();
-              mutex_unlock(&kfd_processes_mutex);
-      }
-
+      kgd2kfd_suspend_process(kfd, run_pm);
      for (i = 0; i < kfd->num_nodes; i++) {
              node = kfd->nodes[i];
              node->dqm->ops.stop(node->dqm); @@ -1055,6 +1047,36 @@

int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm)

                      return ret;
      }
drivers/gpu/drm/amd/amdkfd/kfd_device.c +28 -1
+      ret = kgd2kfd_resume_process(kfd, run_pm);
+
+      return ret;
+}
+
+void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool run_pm) {
+      struct kfd_node *node;
+      int i;
+
+      if (!kfd->init_complete)
+              return;
+
+      /* for runtime suspend, skip locking kfd */
+      if (!run_pm) {
+              mutex_lock(&kfd_processes_mutex);
+              /* For first KFD device suspend all the KFD processes */
+              if (++kfd_locked == 1)
+                      kfd_suspend_all_processes();
+              mutex_unlock(&kfd_processes_mutex);
+      }
+}
+
+int kgd2kfd_resume_process(struct kfd_dev *kfd, bool run_pm) {
+      int ret, i;
+
+      if (!kfd->init_complete)
+              return 0;
+
      /* for runtime resume, skip unlocking kfd */
      if (!run_pm) {
              mutex_lock(&kfd_processes_mutex);
--

2.34.1

#5 lore raw

[AMD Official Use Only - AMD Internal Distribution Only]

Ping......

Emily Deng
Best Wishes

Quoted 269 lines

-----Original Message-----
From: Deng, Emily
Sent: Tuesday, June 3, 2025 5:11 PM
To: Koenig, Christian <[email protected]>; Chen, Horace <[email protected]>
Cc: [email protected]; Zhang, Owen(SRDC) <[email protected]>
Subject: RE: [PATCH v2] drm/amdkfd: Move the process suspend and resume out of full access

Hi Christian and Horace,
Could you help to review this?

Emily Deng
Best Wishes

Quoted 251 lines

-----Original Message-----
From: Zhang, Owen(SRDC) <[email protected]>
Sent: Friday, May 30, 2025 5:50 PM
To: Deng, Emily <[email protected]>; [email protected]
Subject: RE: [PATCH v2] drm/amdkfd: Move the process suspend and resume out of full access

[AMD Official Use Only - AMD Internal Distribution Only]

Hi Team, @[email protected]

Can you pls review and provide your inputs? Thanks for support!

Rgds/Owen

-----Original Message-----
From: Deng, Emily <[email protected]>
Sent: Friday, May 30, 2025 9:39 AM
To: [email protected]
Cc: Zhang, Owen(SRDC) <[email protected]>
Subject: RE: [PATCH v2] drm/amdkfd: Move the process suspend and resume out of full access

[AMD Official Use Only - AMD Internal Distribution Only]

Ping......

Emily Deng
Best Wishes

Quoted 216 lines

-----Original Message-----
From: Deng, Emily <[email protected]>
Sent: Wednesday, May 28, 2025 2:20 PM
To: Deng, Emily <[email protected]>; [email protected]
Cc: Zhang, Owen(SRDC) <[email protected]>
Subject: RE: [PATCH v2] drm/amdkfd: Move the process suspend and resume out of full access

[AMD Official Use Only - AMD Internal Distribution Only]

drivers/gpu/drm/amd/amdkfd/kfd_device.c void kgd2kfd_suspend(struct kfd_dev *kfd, bool

Quoted 151 lines

-----Original Message-----
From: Emily Deng <[email protected]>
Sent: Tuesday, May 27, 2025 6:50 PM
To: [email protected]
Cc: Deng, Emily <[email protected]>
Subject: [PATCH v2] drm/amdkfd: Move the process suspend and resume out of full access

For the suspend and resume process, exclusive access is not required. Therefore, it can be moved out of the full access section to reduce the duration of exclusive access.

---

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c | 16 +++++++++
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h | 13 +++++++
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c | 12 +++++--
drivers/gpu/drm/amd/amdkfd/kfd_device.c    | 40 +++++++++++++++++-----
4 files changed, 70 insertions(+), 11 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c +15 -0
index 4cec3a873995..ba07e9c6619d 100644
@@ -264,6 +264,22 @@ int amdgpu_amdkfd_resume(struct amdgpu_device
 *adev, bool run_pm)
      return r;
 }
 
+void amdgpu_amdkfd_suspend_process(struct amdgpu_device *adev, bool
+run_pm) {
+      if (adev->kfd.dev)
+              kgd2kfd_suspend_process(adev->kfd.dev, run_pm); }
+
+int amdgpu_amdkfd_resume_process(struct amdgpu_device *adev, bool
+run_pm) {
+      int r = 0;
+
+      if (adev->kfd.dev)
+              r = kgd2kfd_resume_process(adev->kfd.dev, run_pm);
+
+      return r;
+}
+
 int amdgpu_amdkfd_pre_reset(struct amdgpu_device *adev,
                          struct amdgpu_reset_context

*reset_context) { diff --git
a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h
b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h
index b6ca41859b53..841ae8b75ab1 100644

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +3 -0
@@ -156,6 +156,8 @@ void amdgpu_amdkfd_fini(void);
 
 void amdgpu_amdkfd_suspend(struct amdgpu_device *adev, bool run_pm);
 int amdgpu_amdkfd_resume(struct amdgpu_device *adev, bool run_pm);
+void amdgpu_amdkfd_suspend_process(struct amdgpu_device *adev, bool
+run_pm); int amdgpu_amdkfd_resume_process(struct amdgpu_device
+*adev, bool run_pm);
 void amdgpu_amdkfd_interrupt(struct amdgpu_device *adev,
                      const void *ih_ring_entry); void

amdgpu_amdkfd_device_probe(struct amdgpu_device *adev); @@ -413,6 +415,8 @@ bool kgd2kfd_device_init(struct kfd_dev *kfd, void kgd2kfd_device_exit(struct kfd_dev *kfd); void kgd2kfd_suspend(struct kfd_dev *kfd, bool run_pm); int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm);

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +2 -0
+void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool run_pm); int
+kgd2kfd_resume_process(struct kfd_dev *kfd, bool run_pm);

int kgd2kfd_pre_reset(struct kfd_dev *kfd,

                    struct amdgpu_reset_context *reset_context);
int kgd2kfd_post_reset(struct kfd_dev *kfd); @@ -463,6 +467,15 @@
static inline int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm)
      return 0;
}
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +8 -0
+static inline void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool
+run_pm) { }
+
+static inline int kgd2kfd_resume_process(struct kfd_dev *kfd, bool
+run_pm) {
+      return 0;
+}
+

static inline int kgd2kfd_pre_reset(struct kfd_dev *kfd,
struct amdgpu_reset_context
*reset_context) { diff -- git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
index 625c416c7d45..6e29f8bd54bb 100644

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +7 -1
@@ -5080,7 +5080,7 @@ int amdgpu_device_suspend(struct drm_device
 *dev, bool
 notify_clients)
      amdgpu_device_ip_suspend_phase1(adev);
 
      if (!adev->in_s0ix) {
-              amdgpu_amdkfd_suspend(adev, adev->in_runpm);
+              amdgpu_amdkfd_suspend(adev,
+ !amdgpu_sriov_runtime(adev)
+ ||
+adev->in_runpm);
              amdgpu_userq_suspend(adev);
      }
@@ -5097,6 +5097,9 @@ int amdgpu_device_suspend(struct drm_device
 *dev, bool
 notify_clients)
      if (amdgpu_sriov_vf(adev))
              amdgpu_virt_release_full_gpu(adev, false);
 
+      if (!adev->in_s0ix)
+              amdgpu_amdkfd_suspend_process(adev, adev->in_runpm);
+
      r = amdgpu_dpm_notify_rlc_state(adev, false);
      if (r)
              return r;
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +8 -1
@@ -5178,7 +5181,7 @@ int amdgpu_device_resume(struct drm_device
 *dev, bool
 notify_clients)
      }
 
      if (!adev->in_s0ix) {
-              r = amdgpu_amdkfd_resume(adev, adev->in_runpm);
+              r = amdgpu_amdkfd_resume(adev,
+ !amdgpu_sriov_runtime(adev) ||
+adev->in_runpm);
              if (r)
                      goto exit;
@@ -5199,6 +5202,11 @@ int amdgpu_device_resume(struct drm_device
 *dev, bool
 notify_clients)
              amdgpu_virt_release_full_gpu(adev, true);
      }
 
+      if (!adev->in_s0ix) {
+              r = amdgpu_amdkfd_resume_process(adev, adev->in_runpm);
+              if (r)
+                      goto exit;
+      }
      if (r)
              return r;
drivers/gpu/drm/amd/amdkfd/kfd_device.c +0 -0
index bf0854bd5555..22c6ef7c42b6 100644
@@ -1027,15 +1027,7 @@ void kgd2kfd_suspend(struct kfd_dev *kfd, bool

run_pm)

Quoted 53 lines
drivers/gpu/drm/amd/amdkfd/kfd_device.c +1 -9
      if (!kfd->init_complete)
              return;
 
-      /* for runtime suspend, skip locking kfd */
-      if (!run_pm) {
-              mutex_lock(&kfd_processes_mutex);
-              /* For first KFD device suspend all the KFD processes */
-              if (++kfd_locked == 1)
-                      kfd_suspend_all_processes();
-              mutex_unlock(&kfd_processes_mutex);
-      }
-
+      kgd2kfd_suspend_process(kfd, run_pm);
      for (i = 0; i < kfd->num_nodes; i++) {
              node = kfd->nodes[i];
              node->dqm->ops.stop(node->dqm); @@ -1055,6 +1047,36 @@

int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm)

                      return ret;
      }
drivers/gpu/drm/amd/amdkfd/kfd_device.c +28 -1
+      ret = kgd2kfd_resume_process(kfd, run_pm);
+
+      return ret;
+}
+
+void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool run_pm) {
+      struct kfd_node *node;
+      int i;
+
+      if (!kfd->init_complete)
+              return;
+
+      /* for runtime suspend, skip locking kfd */
+      if (!run_pm) {
+              mutex_lock(&kfd_processes_mutex);
+              /* For first KFD device suspend all the KFD processes */
+              if (++kfd_locked == 1)
+                      kfd_suspend_all_processes();
+              mutex_unlock(&kfd_processes_mutex);
+      }
+}
+
+int kgd2kfd_resume_process(struct kfd_dev *kfd, bool run_pm) {
+      int ret, i;
+
+      if (!kfd->init_complete)
+              return 0;
+
      /* for runtime resume, skip unlocking kfd */
      if (!run_pm) {
              mutex_lock(&kfd_processes_mutex);
--

2.34.1

#6 lore raw
In reply to Emily Deng
Quoted 110 lines · Emily Deng

For the suspend and resume process, exclusive access is not required. Therefore, it can be moved out of the full access section to reduce the duration of exclusive access.

---
 drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c | 16 +++++++++
 drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h | 13 +++++++
 drivers/gpu/drm/amd/amdgpu/amdgpu_device.c | 12 +++++--
 drivers/gpu/drm/amd/amdkfd/kfd_device.c    | 40 +++++++++++++++++-----
 4 files changed, 70 insertions(+), 11 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c +16 -0
index 4cec3a873995..ba07e9c6619d 100644
@@ -264,6 +264,22 @@ int amdgpu_amdkfd_resume(struct amdgpu_device *adev, bool run_pm)
 	return r;
 }
 
+void amdgpu_amdkfd_suspend_process(struct amdgpu_device *adev, bool run_pm)
+{
+	if (adev->kfd.dev)
+		kgd2kfd_suspend_process(adev->kfd.dev, run_pm);
+}
+
+int amdgpu_amdkfd_resume_process(struct amdgpu_device *adev, bool run_pm)
+{
+	int r = 0;
+
+	if (adev->kfd.dev)
+		r = kgd2kfd_resume_process(adev->kfd.dev, run_pm);
+
+	return r;
+}
+
 int amdgpu_amdkfd_pre_reset(struct amdgpu_device *adev,
 			    struct amdgpu_reset_context *reset_context)
 {
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +13 -0
index b6ca41859b53..841ae8b75ab1 100644
@@ -156,6 +156,8 @@ void amdgpu_amdkfd_fini(void);
 
 void amdgpu_amdkfd_suspend(struct amdgpu_device *adev, bool run_pm);
 int amdgpu_amdkfd_resume(struct amdgpu_device *adev, bool run_pm);
+void amdgpu_amdkfd_suspend_process(struct amdgpu_device *adev, bool run_pm);
+int amdgpu_amdkfd_resume_process(struct amdgpu_device *adev, bool run_pm);
 void amdgpu_amdkfd_interrupt(struct amdgpu_device *adev,
 			const void *ih_ring_entry);
 void amdgpu_amdkfd_device_probe(struct amdgpu_device *adev);
@@ -413,6 +415,8 @@ bool kgd2kfd_device_init(struct kfd_dev *kfd,
 void kgd2kfd_device_exit(struct kfd_dev *kfd);
 void kgd2kfd_suspend(struct kfd_dev *kfd, bool run_pm);
 int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm);
+void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool run_pm);
+int kgd2kfd_resume_process(struct kfd_dev *kfd, bool run_pm);
 int kgd2kfd_pre_reset(struct kfd_dev *kfd,
 		      struct amdgpu_reset_context *reset_context);
 int kgd2kfd_post_reset(struct kfd_dev *kfd);
@@ -463,6 +467,15 @@ static inline int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm)
 	return 0;
 }
 
+static inline void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool run_pm)
+{
+}
+
+static inline int kgd2kfd_resume_process(struct kfd_dev *kfd, bool run_pm)
+{
+	return 0;
+}
+
 static inline int kgd2kfd_pre_reset(struct kfd_dev *kfd,
 				    struct amdgpu_reset_context *reset_context)
 {
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -2
index 625c416c7d45..6e29f8bd54bb 100644
@@ -5080,7 +5080,7 @@ int amdgpu_device_suspend(struct drm_device *dev, bool notify_clients)
 	amdgpu_device_ip_suspend_phase1(adev);
 
 	if (!adev->in_s0ix) {
-		amdgpu_amdkfd_suspend(adev, adev->in_runpm);
+		amdgpu_amdkfd_suspend(adev, !amdgpu_sriov_runtime(adev) || adev->in_runpm);
 		amdgpu_userq_suspend(adev);
 	}
 
@@ -5097,6 +5097,9 @@ int amdgpu_device_suspend(struct drm_device *dev, bool notify_clients)
 	if (amdgpu_sriov_vf(adev))
 		amdgpu_virt_release_full_gpu(adev, false);
 
+	if (!adev->in_s0ix)
+		amdgpu_amdkfd_suspend_process(adev, adev->in_runpm);
+
 	r = amdgpu_dpm_notify_rlc_state(adev, false);
 	if (r)
 		return r;
@@ -5178,7 +5181,7 @@ int amdgpu_device_resume(struct drm_device *dev, bool notify_clients)
 	}
 
 	if (!adev->in_s0ix) {
-		r = amdgpu_amdkfd_resume(adev, adev->in_runpm);
+		r = amdgpu_amdkfd_resume(adev, !amdgpu_sriov_runtime(adev) || adev->in_runpm);
 		if (r)
 			goto exit;
 

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c int amdgpu_device_resume(struct drm_device *dev, bool notify_clients) · line 5206

Quoted 5 lines
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -0
@@ -5199,6 +5202,11 @@ int amdgpu_device_resume(struct drm_device *dev, bool notify_clients)
 		amdgpu_virt_release_full_gpu(adev, true);
 	}
 
+	if (!adev->in_s0ix) {
+		r = amdgpu_amdkfd_resume_process(adev, adev->in_runpm);

Generic logic is to suspend all processes which should also result in stopping any submissions to hardware before proceeding with hardware uninit. How is this different for a VF? Is there a different mechanism done for a gracious suspend/hardware access prevention? Or, does that result in abrupt errors in processes?

That aside, the refactor causes the call to be made twice on bare metal.

Thanks,
Lijo

Quoted 64 lines
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -0
+		if (r)
+			goto exit;
+	}
 	if (r)
 		return r;
 
drivers/gpu/drm/amd/amdkfd/kfd_device.c +31 -9
index bf0854bd5555..22c6ef7c42b6 100644
@@ -1027,15 +1027,7 @@ void kgd2kfd_suspend(struct kfd_dev *kfd, bool run_pm)
 	if (!kfd->init_complete)
 		return;
 
-	/* for runtime suspend, skip locking kfd */
-	if (!run_pm) {
-		mutex_lock(&kfd_processes_mutex);
-		/* For first KFD device suspend all the KFD processes */
-		if (++kfd_locked == 1)
-			kfd_suspend_all_processes();
-		mutex_unlock(&kfd_processes_mutex);
-	}
-
+	kgd2kfd_suspend_process(kfd, run_pm);
 	for (i = 0; i < kfd->num_nodes; i++) {
 		node = kfd->nodes[i];
 		node->dqm->ops.stop(node->dqm);
@@ -1055,6 +1047,36 @@ int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm)
 			return ret;
 	}
 
+	ret = kgd2kfd_resume_process(kfd, run_pm);
+
+	return ret;
+}
+
+void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool run_pm)
+{
+	struct kfd_node *node;
+	int i;
+
+	if (!kfd->init_complete)
+		return;
+
+	/* for runtime suspend, skip locking kfd */
+	if (!run_pm) {
+		mutex_lock(&kfd_processes_mutex);
+		/* For first KFD device suspend all the KFD processes */
+		if (++kfd_locked == 1)
+			kfd_suspend_all_processes();
+		mutex_unlock(&kfd_processes_mutex);
+	}
+}
+
+int kgd2kfd_resume_process(struct kfd_dev *kfd, bool run_pm)
+{
+	int ret, i;
+
+	if (!kfd->init_complete)
+		return 0;
+
 	/* for runtime resume, skip unlocking kfd */
 	if (!run_pm) {
 		mutex_lock(&kfd_processes_mutex);
#7 lore raw

[AMD Official Use Only - AMD Internal Distribution Only]

Quoted 139 lines

-----Original Message-----
From: Lazar, Lijo <[email protected]>
Sent: Wednesday, June 4, 2025 2:54 PM
To: Deng, Emily <[email protected]>; [email protected]
Subject: Re: [PATCH v2] drm/amdkfd: Move the process suspend and resume out of full access

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c int amdgpu_amdkfd_resume(struct amdgpu_device

Quoted 18 lines · Emily Deng

For the suspend and resume process, exclusive access is not required. Therefore, it can be moved out of the full access section to reduce the duration of exclusive access.

---
 drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c | 16 +++++++++
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h | 13 +++++++
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c | 12 +++++--
 drivers/gpu/drm/amd/amdkfd/kfd_device.c    | 40 +++++++++++++++++-----
 4 files changed, 70 insertions(+), 11 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c +0 -0
index 4cec3a873995..ba07e9c6619d 100644
@@ -264,6 +264,22 @@ int amdgpu_amdkfd_resume(struct amdgpu_device

*adev, bool run_pm)

Quoted 48 lines
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c +15 -0
     return r;
 }
 
+void amdgpu_amdkfd_suspend_process(struct amdgpu_device *adev, bool
+run_pm) {
+    if (adev->kfd.dev)
+            kgd2kfd_suspend_process(adev->kfd.dev, run_pm); }
+
+int amdgpu_amdkfd_resume_process(struct amdgpu_device *adev, bool
+run_pm) {
+    int r = 0;
+
+    if (adev->kfd.dev)
+            r = kgd2kfd_resume_process(adev->kfd.dev, run_pm);
+
+    return r;
+}
+
 int amdgpu_amdkfd_pre_reset(struct amdgpu_device *adev,
                         struct amdgpu_reset_context *reset_context)  { diff --git

a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h
b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h
index b6ca41859b53..841ae8b75ab1 100644

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +3 -1
@@ -156,6 +156,8 @@ void amdgpu_amdkfd_fini(void);
 
 void amdgpu_amdkfd_suspend(struct amdgpu_device *adev, bool run_pm);
 int amdgpu_amdkfd_resume(struct amdgpu_device *adev, bool run_pm);
+void amdgpu_amdkfd_suspend_process(struct amdgpu_device *adev, bool
+run_pm); int amdgpu_amdkfd_resume_process(struct amdgpu_device *adev,
+bool run_pm);
 void amdgpu_amdkfd_interrupt(struct amdgpu_device *adev,
                     const void *ih_ring_entry);
 void amdgpu_amdkfd_device_probe(struct amdgpu_device *adev); @@
-413,6 +415,8 @@ bool kgd2kfd_device_init(struct kfd_dev *kfd,  void

kgd2kfd_device_exit(struct kfd_dev *kfd); void kgd2kfd_suspend(struct kfd_dev *kfd, bool run_pm); int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm);

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +2 -0
+void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool run_pm); int
+kgd2kfd_resume_process(struct kfd_dev *kfd, bool run_pm);
 int kgd2kfd_pre_reset(struct kfd_dev *kfd,
                   struct amdgpu_reset_context *reset_context);  int

kgd2kfd_post_reset(struct kfd_dev *kfd); @@ -463,6 +467,15 @@ static inline int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm)

     return 0;

}

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h static inline int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm)

Quoted 10 lines
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +8 -0
+static inline void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool
+run_pm) { }
+
+static inline int kgd2kfd_resume_process(struct kfd_dev *kfd, bool
+run_pm) {
+    return 0;
+}
+
 static inline int kgd2kfd_pre_reset(struct kfd_dev *kfd,
                                 struct amdgpu_reset_context *reset_context)  { diff --

git

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c int amdgpu_device_suspend(struct drm_device *dev,

Quoted 6 lines

a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
index 625c416c7d45..6e29f8bd54bb 100644

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
@@ -5080,7 +5080,7 @@ int amdgpu_device_suspend(struct drm_device *dev,

bool notify_clients)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c int amdgpu_device_suspend(struct drm_device *dev,

Quoted 10 lines
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -1
     amdgpu_device_ip_suspend_phase1(adev);
 
     if (!adev->in_s0ix) {
-            amdgpu_amdkfd_suspend(adev, adev->in_runpm);
+            amdgpu_amdkfd_suspend(adev, !amdgpu_sriov_runtime(adev) ||
+adev->in_runpm);
             amdgpu_userq_suspend(adev);
     }
@@ -5097,6 +5097,9 @@ int amdgpu_device_suspend(struct drm_device *dev,

bool notify_clients)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c int amdgpu_device_resume(struct drm_device *dev,

Quoted 10 lines
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -0
     if (amdgpu_sriov_vf(adev))
             amdgpu_virt_release_full_gpu(adev, false);
 
+    if (!adev->in_s0ix)
+            amdgpu_amdkfd_suspend_process(adev, adev->in_runpm);
+
     r = amdgpu_dpm_notify_rlc_state(adev, false);
     if (r)
             return r;
@@ -5178,7 +5181,7 @@ int amdgpu_device_resume(struct drm_device *dev,

bool notify_clients)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c int amdgpu_device_resume(struct drm_device *dev,

Quoted 10 lines
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -1
     }
 
     if (!adev->in_s0ix) {
-            r = amdgpu_amdkfd_resume(adev, adev->in_runpm);
+            r = amdgpu_amdkfd_resume(adev, !amdgpu_sriov_runtime(adev) ||
+adev->in_runpm);
             if (r)
                     goto exit;
@@ -5199,6 +5202,11 @@ int amdgpu_device_resume(struct drm_device *dev,

bool notify_clients)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c int amdgpu_device_resume(struct drm_device *dev, bool notify_clients) · line 5206

Quoted 5 lines
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -0
             amdgpu_virt_release_full_gpu(adev, true);
     }
 
+    if (!adev->in_s0ix) {
+            r = amdgpu_amdkfd_resume_process(adev, adev->in_runpm);

Generic logic is to suspend all processes which should also result in stopping any submissions to hardware before proceeding with hardware uninit. How is this different for a VF? Is there a different mechanism done for a gracious suspend/hardware access prevention? Or, does that result in abrupt errors in processes?

Quoted 4 lines

That aside, the refactor causes the call to be made twice on bare metal.

Thanks,
Lijo

You are right, should suspend all processes before hardware fini. And will also repair the twice issue for bare metal.

Emily Deng
Best Wishes

Quoted 65 lines

drivers/gpu/drm/amd/amdkfd/kfd_device.c void kgd2kfd_suspend(struct kfd_dev *kfd, bool

Quoted 13 lines
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -0
+            if (r)
+                    goto exit;
+    }
     if (r)
             return r;
 
drivers/gpu/drm/amd/amdkfd/kfd_device.c +0 -0
index bf0854bd5555..22c6ef7c42b6 100644
@@ -1027,15 +1027,7 @@ void kgd2kfd_suspend(struct kfd_dev *kfd, bool

run_pm)

Quoted 51 lines
drivers/gpu/drm/amd/amdkfd/kfd_device.c +29 -9
     if (!kfd->init_complete)
             return;
 
-    /* for runtime suspend, skip locking kfd */
-    if (!run_pm) {
-            mutex_lock(&kfd_processes_mutex);
-            /* For first KFD device suspend all the KFD processes */
-            if (++kfd_locked == 1)
-                    kfd_suspend_all_processes();
-            mutex_unlock(&kfd_processes_mutex);
-    }
-
+    kgd2kfd_suspend_process(kfd, run_pm);
     for (i = 0; i < kfd->num_nodes; i++) {
             node = kfd->nodes[i];
             node->dqm->ops.stop(node->dqm);
@@ -1055,6 +1047,36 @@ int kgd2kfd_resume(struct kfd_dev *kfd, bool run_pm)
                     return ret;
     }
 
+    ret = kgd2kfd_resume_process(kfd, run_pm);
+
+    return ret;
+}
+
+void kgd2kfd_suspend_process(struct kfd_dev *kfd, bool run_pm) {
+    struct kfd_node *node;
+    int i;
+
+    if (!kfd->init_complete)
+            return;
+
+    /* for runtime suspend, skip locking kfd */
+    if (!run_pm) {
+            mutex_lock(&kfd_processes_mutex);
+            /* For first KFD device suspend all the KFD processes */
+            if (++kfd_locked == 1)
+                    kfd_suspend_all_processes();
+            mutex_unlock(&kfd_processes_mutex);
+    }
+}
+
+int kgd2kfd_resume_process(struct kfd_dev *kfd, bool run_pm) {
+    int ret, i;
+
+    if (!kfd->init_complete)
+            return 0;
+
     /* for runtime resume, skip unlocking kfd */
     if (!run_pm) {
             mutex_lock(&kfd_processes_mutex);