5 files changed, 38 insertions, 34 deletions

diff --git a/drivers/gpu/nvgpu/gk20a/gr_gk20a.c b/drivers/gpu/nvgpu/gk20a/gr_gk20a.c
index 63ae1da1..b23cabe8 100644
--- a/drivers/gpu/nvgpu/gk20a/gr_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/gr_gk20a.c
@@ -20,7 +20,6 @@
 #include <linux/delay.h>        /* for udelay */
 #include <linux/mm.h>           /* for totalram_pages */
 #include <linux/scatterlist.h>
-#include <soc/tegra/chip-id.h>
 #include <linux/debugfs.h>
 #include <uapi/linux/nvgpu.h>
 #include <linux/vmalloc.h>
@@ -1587,7 +1586,6 @@ static int gr_gk20a_init_golden_ctx_image(struct gk20a *g,
         struct aiv_list_gk20a *sw_ctx_load = &g->gr.ctx_vars.sw_ctx_load;
         struct av_list_gk20a *sw_method_init = &g->gr.ctx_vars.sw_method_init;
         u32 last_method_data = 0;
-        int retries = FE_PWR_MODE_TIMEOUT_MAX / FE_PWR_MODE_TIMEOUT_DEFAULT;
         struct gk20a_platform *platform = dev_get_drvdata(g->dev);
         struct ctx_header_desc *ctx = &c->ch_ctx.ctx_header;
         struct mem_desc *ctxheader = &ctx->mem;
@@ -1603,18 +1601,21 @@ static int gr_gk20a_init_golden_ctx_image(struct gk20a *g,
                 goto clean_up;
         }
         if (!platform->is_fmodel) {
+                struct nvgpu_timeout timeout;
+
+                nvgpu_timeout_init(g, &timeout, FE_PWR_MODE_TIMEOUT_MAX / 1000,
+                                   NVGPU_TIMER_CPU_TIMER);
                 gk20a_writel(g, gr_fe_pwr_mode_r(),
                         gr_fe_pwr_mode_req_send_f() | gr_fe_pwr_mode_mode_force_on_f());
                 do {
                         u32 req = gr_fe_pwr_mode_req_v(gk20a_readl(g, gr_fe_pwr_mode_r()));
                         if (req == gr_fe_pwr_mode_req_done_v())
                                 break;
-                        udelay(FE_PWR_MODE_TIMEOUT_MAX);
-                } while (--retries || !tegra_platform_is_silicon());
+                        udelay(FE_PWR_MODE_TIMEOUT_DEFAULT);
+                } while (!nvgpu_timeout_expired_msg(&timeout,
+                                                    "timeout forcing FE on"));
         }
 
-        if (!retries)
-                gk20a_err(g->dev, "timeout forcing FE on");
 
         gk20a_writel(g, gr_fecs_ctxsw_reset_ctl_r(),
                         gr_fecs_ctxsw_reset_ctl_sys_halt_disabled_f() |
@@ -1643,19 +1644,20 @@ static int gr_gk20a_init_golden_ctx_image(struct gk20a *g,
         udelay(10);
 
         if (!platform->is_fmodel) {
+                struct nvgpu_timeout timeout;
+
+                nvgpu_timeout_init(g, &timeout, FE_PWR_MODE_TIMEOUT_MAX / 1000,
+                                   NVGPU_TIMER_CPU_TIMER);
                 gk20a_writel(g, gr_fe_pwr_mode_r(),
                         gr_fe_pwr_mode_req_send_f() | gr_fe_pwr_mode_mode_auto_f());
 
-                retries = FE_PWR_MODE_TIMEOUT_MAX / FE_PWR_MODE_TIMEOUT_DEFAULT;
                 do {
                         u32 req = gr_fe_pwr_mode_req_v(gk20a_readl(g, gr_fe_pwr_mode_r()));
                         if (req == gr_fe_pwr_mode_req_done_v())
                                 break;
                         udelay(FE_PWR_MODE_TIMEOUT_DEFAULT);
-                } while (--retries || !tegra_platform_is_silicon());
-
-                if (!retries)
-                        gk20a_err(g->dev, "timeout setting FE power to auto");
+                } while (!nvgpu_timeout_expired_msg(&timeout,
+                                                    "timeout setting FE power to auto"));
         }
 
         /* clear scc ram */
@@ -4996,13 +4998,14 @@ static int gk20a_init_gr_prepare(struct gk20a *g)
 
 static int gr_gk20a_wait_mem_scrubbing(struct gk20a *g)
 {
-        int retries = CTXSW_MEM_SCRUBBING_TIMEOUT_MAX /
-                      CTXSW_MEM_SCRUBBING_TIMEOUT_DEFAULT;
+        struct nvgpu_timeout timeout;
         bool fecs_scrubbing;
         bool gpccs_scrubbing;
 
         gk20a_dbg_fn("");
 
+        nvgpu_timeout_init(g, &timeout, CTXSW_MEM_SCRUBBING_TIMEOUT_MAX / 1000,
+                           NVGPU_TIMER_CPU_TIMER);
         do {
                 fecs_scrubbing = gk20a_readl(g, gr_fecs_dmactl_r()) &
                         (gr_fecs_dmactl_imem_scrubbing_m() |
@@ -5018,7 +5021,7 @@ static int gr_gk20a_wait_mem_scrubbing(struct gk20a *g)
                 }
 
                 udelay(CTXSW_MEM_SCRUBBING_TIMEOUT_DEFAULT);
-        } while (--retries || !tegra_platform_is_silicon());
+        } while (!nvgpu_timeout_expired(&timeout));
 
         gk20a_err(dev_from_gk20a(g), "Falcon mem scrubbing timeout");
         return -ETIMEDOUT;
@@ -8663,8 +8666,7 @@ int gk20a_gr_wait_for_sm_lock_down(struct gk20a *g, u32 gpc, u32 tpc,
 
                 usleep_range(delay, delay * 2);
                 delay = min_t(u32, delay << 1, GR_IDLE_CHECK_MAX);
-        } while (!nvgpu_timeout_expired(&timeout)
-                        || !tegra_platform_is_silicon());
+        } while (!nvgpu_timeout_expired(&timeout));
 
         dbgr_control0 = gk20a_readl(g,
                                 gr_gpc0_tpc0_sm_dbgr_control0_r() + offset);
diff --git a/drivers/gpu/nvgpu/gk20a/ltc_gk20a.c b/drivers/gpu/nvgpu/gk20a/ltc_gk20a.c
index 34a96971..9942e58f 100644
--- a/drivers/gpu/nvgpu/gk20a/ltc_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/ltc_gk20a.c
@@ -17,7 +17,9 @@
  */
 
 #include <linux/kernel.h>
+
 #include <trace/events/gk20a.h>
+#include <nvgpu/timers.h>
 
 #include "gk20a.h"
 
@@ -106,7 +108,6 @@ static int gk20a_ltc_cbc_ctrl(struct gk20a *g, enum gk20a_cbc_op op,
         int err = 0;
         struct gr_gk20a *gr = &g->gr;
         u32 fbp, slice, ctrl1, val, hw_op = 0;
-        int retry = 200;
         u32 slices_per_fbp =
                 ltc_ltcs_ltss_cbc_param_slices_per_fbp_v(
                         gk20a_readl(g, ltc_ltcs_ltss_cbc_param_r()));
@@ -140,6 +141,9 @@ static int gk20a_ltc_cbc_ctrl(struct gk20a *g, enum gk20a_cbc_op op,
                      gk20a_readl(g, ltc_ltcs_ltss_cbc_ctrl1_r()) | hw_op);
 
         for (fbp = 0; fbp < gr->num_fbps; fbp++) {
+                struct nvgpu_timeout timeout;
+
+                nvgpu_timeout_init(g, &timeout, 200, NVGPU_TIMER_RETRY_TIMER);
                 for (slice = 0; slice < slices_per_fbp; slice++) {
 
 
@@ -147,18 +151,15 @@ static int gk20a_ltc_cbc_ctrl(struct gk20a *g, enum gk20a_cbc_op op,
                                 fbp * ltc_stride +
                                 slice * lts_stride;
 
-                        retry = 200;
                         do {
                                 val = gk20a_readl(g, ctrl1);
                                 if (!(val & hw_op))
                                         break;
-                                retry--;
                                 udelay(5);
 
-                        } while (retry >= 0 ||
-                                        !tegra_platform_is_silicon());
+                        } while (!nvgpu_timeout_expired(&timeout));
 
-                        if (retry < 0 && tegra_platform_is_silicon()) {
+                        if (nvgpu_timeout_peek_expired(&timeout)) {
                                 gk20a_err(dev_from_gk20a(g),
                                            "comp tag clear timeout\n");
                                 err = -EBUSY;
diff --git a/drivers/gpu/nvgpu/gk20a/mm_gk20a.c b/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
index 9e6dc74c..c31f8482 100644
--- a/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/mm_gk20a.c
@@ -22,7 +22,6 @@
 #include <linux/nvhost.h>
 #include <linux/scatterlist.h>
 #include <linux/nvmap.h>
-#include <soc/tegra/chip-id.h>
 #include <linux/vmalloc.h>
 #include <linux/dma-buf.h>
 #include <linux/dma-mapping.h>
@@ -1543,7 +1542,6 @@ static void gk20a_vm_unmap_user(struct vm_gk20a *vm, u64 offset,
                                 struct vm_gk20a_mapping_batch *batch)
 {
         struct device *d = dev_from_vm(vm);
-        int retries = 10000; /* 50 ms */
         struct mapped_buffer_node *mapped_buffer;
 
         nvgpu_mutex_acquire(&vm->update_gmmu_lock);
@@ -1556,17 +1554,19 @@ static void gk20a_vm_unmap_user(struct vm_gk20a *vm, u64 offset,
         }
 
         if (mapped_buffer->flags & NVGPU_AS_MAP_BUFFER_FLAGS_FIXED_OFFSET) {
+                struct nvgpu_timeout timeout;
+
                 nvgpu_mutex_release(&vm->update_gmmu_lock);
 
-                while (retries >= 0 || !tegra_platform_is_silicon()) {
+                nvgpu_timeout_init(vm->mm->g, &timeout, 10000,
+                                   NVGPU_TIMER_RETRY_TIMER);
+                do {
                         if (atomic_read(&mapped_buffer->ref.refcount) == 1)
                                 break;
-                        retries--;
                         udelay(5);
-                }
-                if (retries < 0 && tegra_platform_is_silicon())
-                        gk20a_err(d, "sync-unmap failed on 0x%llx",
-                                                                offset);
+                } while (!nvgpu_timeout_expired_msg(&timeout,
+                                            "sync-unmap failed on 0x%llx"));
+
                 nvgpu_mutex_acquire(&vm->update_gmmu_lock);
         }
 
diff --git a/drivers/gpu/nvgpu/gk20a/mm_gk20a.h b/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
index 52e5d4db..81a0aac9 100644
--- a/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
+++ b/drivers/gpu/nvgpu/gk20a/mm_gk20a.h
@@ -20,7 +20,6 @@
 
 #include <linux/scatterlist.h>
 #include <linux/iommu.h>
-#include <soc/tegra/chip-id.h>
 #include <linux/vmalloc.h>
 #include <linux/slab.h>
 #include <linux/version.h>
diff --git a/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c b/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c
index 993cef7b..85fa8ea1 100644
--- a/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c
@@ -2374,12 +2374,11 @@ void pmu_enable_irq(struct pmu_gk20a *pmu, bool enable)
 int pmu_enable_hw(struct pmu_gk20a *pmu, bool enable)
 {
         struct gk20a *g = gk20a_from_pmu(pmu);
+        struct nvgpu_timeout timeout;
 
         gk20a_dbg_fn("");
 
         if (enable) {
-                int retries = PMU_MEM_SCRUBBING_TIMEOUT_MAX /
-                              PMU_MEM_SCRUBBING_TIMEOUT_DEFAULT;
                 g->ops.mc.enable(g, mc_enable_pwr_enabled_f());
 
                 if (g->ops.clock_gating.slcg_pmu_load_gating_prod)
@@ -2389,6 +2388,9 @@ int pmu_enable_hw(struct pmu_gk20a *pmu, bool enable)
                         g->ops.clock_gating.blcg_pmu_load_gating_prod(g,
                                         g->blcg_enabled);
 
+                nvgpu_timeout_init(g, &timeout,
+                                   PMU_MEM_SCRUBBING_TIMEOUT_MAX / 1000,
+                                   NVGPU_TIMER_CPU_TIMER);
                 do {
                         u32 w = gk20a_readl(g, pwr_falcon_dmactl_r()) &
                                 (pwr_falcon_dmactl_dmem_scrubbing_m() |
@@ -2399,7 +2401,7 @@ int pmu_enable_hw(struct pmu_gk20a *pmu, bool enable)
                                 return 0;
                         }
                         udelay(PMU_MEM_SCRUBBING_TIMEOUT_DEFAULT);
-                } while (--retries || !tegra_platform_is_silicon());
+                } while (!nvgpu_timeout_expired(&timeout));
 
                 g->ops.mc.disable(g, mc_enable_pwr_enabled_f());
                 gk20a_err(dev_from_gk20a(g), "Falcon mem scrubbing timeout");