3 files changed, 70 insertions, 12 deletions

diff --git a/drivers/gpu/nvgpu/include/nvgpu/gk20a.h b/drivers/gpu/nvgpu/include/nvgpu/gk20a.h
index aa95969d..3b193dbe 100644
--- a/drivers/gpu/nvgpu/include/nvgpu/gk20a.h
+++ b/drivers/gpu/nvgpu/include/nvgpu/gk20a.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011-2020, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright (c) 2011-2021, NVIDIA CORPORATION.  All rights reserved.
  *
  * GK20A Graphics
  *
@@ -1793,6 +1793,8 @@ bool gk20a_check_poweron(struct gk20a *g);
 int gk20a_prepare_poweroff(struct gk20a *g);
 int gk20a_finalize_poweron(struct gk20a *g);
 
+int nvgpu_wait_for_stall_interrupts(struct gk20a *g, u32 timeout);
+int nvgpu_wait_for_nonstall_interrupts(struct gk20a *g, u32 timeout);
 void nvgpu_wait_for_deferred_interrupts(struct gk20a *g);
 
 struct gk20a * __must_check gk20a_get(struct gk20a *g);
diff --git a/drivers/gpu/nvgpu/os/linux/driver_common.c b/drivers/gpu/nvgpu/os/linux/driver_common.c
index c76dabeb..602d325d 100644
--- a/drivers/gpu/nvgpu/os/linux/driver_common.c
+++ b/drivers/gpu/nvgpu/os/linux/driver_common.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2018, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright (c) 2016-2021, NVIDIA CORPORATION.  All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -312,30 +312,70 @@ static int cyclic_delta(int a, int b)
 }
 
 /**
- * nvgpu_wait_for_deferred_interrupts - Wait for interrupts to complete
+ * nvgpu_wait_for_stall_interrupts - Wait for the stalling interrupts to
+ *                                   complete.
  *
  * @g - The GPU to wait on.
+ * @timeout - maximum time period to wait for.
  *
- * Waits until all interrupt handlers that have been scheduled to run have
- * completed.
+ * Waits until all stalling interrupt handlers that have been scheduled to run
+ * have completed.
  */
-void nvgpu_wait_for_deferred_interrupts(struct gk20a *g)
+int nvgpu_wait_for_stall_interrupts(struct gk20a *g, u32 timeout)
 {
         struct nvgpu_os_linux *l = nvgpu_os_linux_from_gk20a(g);
         int stall_irq_threshold = atomic_read(&l->hw_irq_stall_count);
-        int nonstall_irq_threshold = atomic_read(&l->hw_irq_nonstall_count);
 
         /* wait until all stalling irqs are handled */
-        NVGPU_COND_WAIT(&l->sw_irq_stall_last_handled_wq,
+        return NVGPU_COND_WAIT(&l->sw_irq_stall_last_handled_wq,
                    cyclic_delta(stall_irq_threshold,
                                 atomic_read(&l->sw_irq_stall_last_handled))
-                   <= 0, 0);
+                   <= 0, timeout);
+}
+
+/**
+ * nvgpu_wait_for_nonstall_interrupts - Wait for the nonstalling interrupts to
+ *                                      complete.
+ *
+ * @g - The GPU to wait on.
+ * @timeout - maximum time period to wait for.
+ *
+ * Waits until all non-stalling interrupt handlers that have been scheduled to
+ * run have completed.
+ */
+int nvgpu_wait_for_nonstall_interrupts(struct gk20a *g, u32 timeout)
+{
+        struct nvgpu_os_linux *l = nvgpu_os_linux_from_gk20a(g);
+        int nonstall_irq_threshold = atomic_read(&l->hw_irq_nonstall_count);
 
         /* wait until all non-stalling irqs are handled */
-        NVGPU_COND_WAIT(&l->sw_irq_nonstall_last_handled_wq,
+        return NVGPU_COND_WAIT(&l->sw_irq_nonstall_last_handled_wq,
                    cyclic_delta(nonstall_irq_threshold,
                                 atomic_read(&l->sw_irq_nonstall_last_handled))
-                   <= 0, 0);
+                   <= 0, timeout);
+}
+
+/**
+ * nvgpu_wait_for_deferred_interrupts - Wait for interrupts to complete
+ *
+ * @g - The GPU to wait on.
+ *
+ * Waits until all interrupt handlers that have been scheduled to run have
+ * completed.
+ */
+void nvgpu_wait_for_deferred_interrupts(struct gk20a *g)
+{
+        int ret;
+
+        ret = nvgpu_wait_for_stall_interrupts(g, 0U);
+        if (ret != 0) {
+                nvgpu_err(g, "wait for stall interrupts failed %d", ret);
+        }
+
+        ret = nvgpu_wait_for_nonstall_interrupts(g, 0U);
+        if (ret != 0) {
+                nvgpu_err(g, "wait for nonstall interrupts failed %d", ret);
+        }
 }
 
 static void nvgpu_free_gk20a(struct gk20a *g)
diff --git a/drivers/gpu/nvgpu/os/posix/nvgpu.c b/drivers/gpu/nvgpu/os/posix/nvgpu.c
index e485ed73..5b68113c 100644
--- a/drivers/gpu/nvgpu/os/posix/nvgpu.c
+++ b/drivers/gpu/nvgpu/os/posix/nvgpu.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright (c) 2018-2021, NVIDIA CORPORATION.  All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -36,6 +36,22 @@
 
 #include "os_posix.h"
 
+int nvgpu_wait_for_stall_interrupts(struct gk20a *g, u32 timeout)
+{
+        /*
+         * No interrupts in userspace so nothing to wait for.
+         */
+        return 0;
+}
+
+int nvgpu_wait_for_nonstall_interrupts(struct gk20a *g, u32 timeout)
+{
+        /*
+         * No interrupts in userspace so nothing to wait for.
+         */
+        return 0;
+}
+
 void nvgpu_wait_for_deferred_interrupts(struct gk20a *g)
 {
         /*