5 files changed, 62 insertions, 6 deletions

diff --git a/drivers/gpu/nvgpu/common/linux/nvhost.c b/drivers/gpu/nvgpu/common/linux/nvhost.c
index a76953e3..fa169cf0 100644
--- a/drivers/gpu/nvgpu/common/linux/nvhost.c
+++ b/drivers/gpu/nvgpu/common/linux/nvhost.c
@@ -166,6 +166,25 @@ u32 nvgpu_nvhost_syncpt_read_maxval(
         return nvhost_syncpt_read_maxval(nvhost_dev->host1x_pdev, id);
 }
 
+void nvgpu_nvhost_syncpt_set_safe_state(
+        struct nvgpu_nvhost_dev *nvhost_dev, u32 id)
+{
+        u32 val;
+
+        /*
+         * Add large number of increments to current value
+         * so that all waiters on this syncpoint are released
+         *
+         * We don't expect any case where more than 0x10000 increments
+         * are pending
+         */
+        val = nvhost_syncpt_read_minval(nvhost_dev->host1x_pdev, id);
+        val += 0x10000;
+
+        nvhost_syncpt_set_minval(nvhost_dev->host1x_pdev, id, val);
+        nvhost_syncpt_set_maxval(nvhost_dev->host1x_pdev, id, val);
+}
+
 int nvgpu_nvhost_create_symlink(struct gk20a *g)
 {
         struct device *dev = dev_from_gk20a(g);
diff --git a/drivers/gpu/nvgpu/gk20a/channel_gk20a.c b/drivers/gpu/nvgpu/gk20a/channel_gk20a.c
index 78953558..65b17304 100644
--- a/drivers/gpu/nvgpu/gk20a/channel_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/channel_gk20a.c
@@ -196,6 +196,8 @@ void gk20a_channel_abort_clean_up(struct channel_gk20a *ch)
         nvgpu_mutex_acquire(&ch->sync_lock);
         if (ch->sync)
                 ch->sync->set_min_eq_max(ch->sync);
+        if (ch->user_sync)
+                ch->user_sync->set_safe_state(ch->user_sync);
         nvgpu_mutex_release(&ch->sync_lock);
 
         /* release all job semaphores (applies only to jobs that use
@@ -435,11 +437,18 @@ static void gk20a_free_channel(struct channel_gk20a *ch, bool force)
         /* sync must be destroyed before releasing channel vm */
         nvgpu_mutex_acquire(&ch->sync_lock);
         if (ch->sync) {
-                gk20a_channel_sync_destroy(ch->sync);
+                gk20a_channel_sync_destroy(ch->sync, false);
                 ch->sync = NULL;
         }
         if (ch->user_sync) {
-                gk20a_channel_sync_destroy(ch->user_sync);
+                /*
+                 * Set user managed syncpoint to safe state
+                 * But it's already done if channel has timedout
+                 */
+                if (ch->has_timedout)
+                        gk20a_channel_sync_destroy(ch->user_sync, false);
+                else
+                        gk20a_channel_sync_destroy(ch->user_sync, true);
                 ch->user_sync = NULL;
         }
         nvgpu_mutex_release(&ch->sync_lock);
@@ -1211,7 +1220,7 @@ clean_up_prealloc:
                 channel_gk20a_free_prealloc_resources(c);
 clean_up_sync:
         if (c->sync) {
-                gk20a_channel_sync_destroy(c->sync);
+                gk20a_channel_sync_destroy(c->sync, false);
                 c->sync = NULL;
         }
 clean_up_unmap:
@@ -1905,7 +1914,8 @@ void gk20a_channel_clean_up_jobs(struct channel_gk20a *c,
                                 if (nvgpu_atomic_dec_and_test(
                                         &c->sync->refcount) &&
                                                 g->aggressive_sync_destroy) {
-                                        gk20a_channel_sync_destroy(c->sync);
+                                        gk20a_channel_sync_destroy(c->sync,
+                                                false);
                                         c->sync = NULL;
                                 }
                                 nvgpu_mutex_release(&c->sync_lock);
diff --git a/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.c b/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.c
index 3c12147f..236ddaaf 100644
--- a/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.c
@@ -280,6 +280,13 @@ static void gk20a_channel_syncpt_set_min_eq_max(struct gk20a_channel_sync *s)
         nvgpu_nvhost_syncpt_set_min_eq_max_ext(sp->nvhost_dev, sp->id);
 }
 
+static void gk20a_channel_syncpt_set_safe_state(struct gk20a_channel_sync *s)
+{
+        struct gk20a_channel_syncpt *sp =
+                container_of(s, struct gk20a_channel_syncpt, ops);
+        nvgpu_nvhost_syncpt_set_safe_state(sp->nvhost_dev, sp->id);
+}
+
 static void gk20a_channel_syncpt_signal_timeline(
                 struct gk20a_channel_sync *s)
 {
@@ -357,6 +364,7 @@ gk20a_channel_syncpt_create(struct channel_gk20a *c, bool user_managed)
         sp->ops.incr_wfi                = gk20a_channel_syncpt_incr_wfi;
         sp->ops.incr_user               = gk20a_channel_syncpt_incr_user;
         sp->ops.set_min_eq_max          = gk20a_channel_syncpt_set_min_eq_max;
+        sp->ops.set_safe_state          = gk20a_channel_syncpt_set_safe_state;
         sp->ops.signal_timeline         = gk20a_channel_syncpt_signal_timeline;
         sp->ops.syncpt_id               = gk20a_channel_syncpt_id;
         sp->ops.syncpt_address          = gk20a_channel_syncpt_address;
@@ -634,6 +642,11 @@ static void gk20a_channel_semaphore_set_min_eq_max(struct gk20a_channel_sync *s)
         /* Nothing to do. */
 }
 
+static void gk20a_channel_semaphore_set_safe_state(struct gk20a_channel_sync *s)
+{
+        /* Nothing to do. */
+}
+
 static void gk20a_channel_semaphore_signal_timeline(
                 struct gk20a_channel_sync *s)
 {
@@ -703,6 +716,7 @@ gk20a_channel_semaphore_create(struct channel_gk20a *c, bool user_managed)
         sema->ops.incr_wfi      = gk20a_channel_semaphore_incr_wfi;
         sema->ops.incr_user     = gk20a_channel_semaphore_incr_user;
         sema->ops.set_min_eq_max = gk20a_channel_semaphore_set_min_eq_max;
+        sema->ops.set_safe_state = gk20a_channel_semaphore_set_safe_state;
         sema->ops.signal_timeline = gk20a_channel_semaphore_signal_timeline;
         sema->ops.syncpt_id     = gk20a_channel_semaphore_syncpt_id;
         sema->ops.syncpt_address = gk20a_channel_semaphore_syncpt_address;
@@ -711,8 +725,11 @@ gk20a_channel_semaphore_create(struct channel_gk20a *c, bool user_managed)
         return &sema->ops;
 }
 
-void gk20a_channel_sync_destroy(struct gk20a_channel_sync *sync)
+void gk20a_channel_sync_destroy(struct gk20a_channel_sync *sync,
+        bool set_safe_state)
 {
+        if (set_safe_state)
+                sync->set_safe_state(sync);
         sync->destroy(sync);
 }
 
diff --git a/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.h b/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.h
index 3f44b27a..da8cb251 100644
--- a/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.h
+++ b/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.h
@@ -86,6 +86,13 @@ struct gk20a_channel_sync {
         /* Reset the channel syncpoint/semaphore. */
         void (*set_min_eq_max)(struct gk20a_channel_sync *s);
 
+        /*
+         * Set the channel syncpoint/semaphore to safe state
+         * This should be used to reset User managed syncpoint since we don't
+         * track threshold values for those syncpoints
+         */
+        void (*set_safe_state)(struct gk20a_channel_sync *s);
+
         /* Signals the sync timeline (if owned by the gk20a_channel_sync layer).
          * This should be called when we notice that a gk20a_fence is
          * expired. */
@@ -101,7 +108,8 @@ struct gk20a_channel_sync {
         void (*destroy)(struct gk20a_channel_sync *s);
 };
 
-void gk20a_channel_sync_destroy(struct gk20a_channel_sync *sync);
+void gk20a_channel_sync_destroy(struct gk20a_channel_sync *sync,
+        bool set_safe_state);
 struct gk20a_channel_sync *gk20a_channel_sync_create(struct channel_gk20a *c,
         bool user_managed);
 bool gk20a_channel_sync_needs_sync_framework(struct gk20a *g);
diff --git a/drivers/gpu/nvgpu/include/nvgpu/nvhost.h b/drivers/gpu/nvgpu/include/nvgpu/nvhost.h
index d5b5831a..13de012a 100644
--- a/drivers/gpu/nvgpu/include/nvgpu/nvhost.h
+++ b/drivers/gpu/nvgpu/include/nvgpu/nvhost.h
@@ -52,6 +52,8 @@ int nvgpu_nvhost_syncpt_read_ext_check(struct nvgpu_nvhost_dev *nvhost_dev,
         u32 id, u32 *val);
 u32 nvgpu_nvhost_syncpt_read_maxval(struct nvgpu_nvhost_dev *nvhost_dev,
         u32 id);
+void nvgpu_nvhost_syncpt_set_safe_state(
+        struct nvgpu_nvhost_dev *nvhost_dev, u32 id);
 
 int nvgpu_nvhost_intr_register_notifier(struct nvgpu_nvhost_dev *nvhost_dev,
         u32 id, u32 thresh, void (*callback)(void *, int), void *private_data);