diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
index 2253c154a824..958d6677b3a6 100644
--- a/drivers/clk/clk.c
+++ b/drivers/clk/clk.c
@@ -1080,7 +1080,7 @@ int clk_prepare(struct clk *clk)
 }
 EXPORT_SYMBOL_GPL(clk_prepare);
 
-static void clk_core_disable(struct clk_core *core)
+static void clk_core_disable(struct clk_core *core, bool sync)
 {
 	lockdep_assert_held(&enable_lock);
 
@@ -1102,17 +1102,20 @@ static void clk_core_disable(struct clk_core *core)
 	if (core->ops->disable)
 		core->ops->disable(core->hw);
 
+	if (sync && core->ops->disable_sync)
+		core->ops->disable_sync(core->hw);
+
 	trace_clk_disable_complete(core);
 
-	clk_core_disable(core->parent);
+	clk_core_disable(core->parent, false);
 }
 
-static void clk_core_disable_lock(struct clk_core *core)
+static void clk_core_disable_lock(struct clk_core *core, bool sync)
 {
 	unsigned long flags;
 
 	flags = clk_enable_lock();
-	clk_core_disable(core);
+	clk_core_disable(core, sync);
 	clk_enable_unlock(flags);
 }
 
@@ -1133,10 +1136,25 @@ void clk_disable(struct clk *clk)
 	if (IS_ERR_OR_NULL(clk))
 		return;
 
-	clk_core_disable_lock(clk->core);
+	clk_core_disable_lock(clk->core, false);
 }
 EXPORT_SYMBOL_GPL(clk_disable);
 
+/**
+ * clk_disable_sync - gate a clock synchronously
+ * @clk: the clk being gated
+ *
+ * It is similar to clk_disable, but guarantees that clk is gated synchronously.
+ */
+void clk_disable_sync(struct clk *clk)
+{
+	if (IS_ERR_OR_NULL(clk))
+		return;
+
+	clk_core_disable_lock(clk->core, true);
+}
+EXPORT_SYMBOL_GPL(clk_disable_sync);
+
 static int clk_core_enable(struct clk_core *core)
 {
 	int ret = 0;
@@ -1164,7 +1182,7 @@ static int clk_core_enable(struct clk_core *core)
 		trace_clk_enable_complete(core);
 
 		if (ret) {
-			clk_core_disable(core->parent);
+			clk_core_disable(core->parent, false);
 			return ret;
 		}
 	}
@@ -1340,7 +1358,7 @@ static int clk_core_prepare_enable(struct clk_core *core)
 
 static void clk_core_disable_unprepare(struct clk_core *core)
 {
-	clk_core_disable_lock(core);
+	clk_core_disable_lock(core, false);
 	clk_core_unprepare_lock(core);
 }
 
@@ -2058,7 +2076,7 @@ static void __clk_set_parent_after(struct clk_core *core,
 	 * for preventing a race with clk_enable().
 	 */
 	if (core->prepare_count) {
-		clk_core_disable_lock(core);
+		clk_core_disable_lock(core, false);
 		clk_core_disable_unprepare(old_parent);
 	}
 
@@ -2352,7 +2370,7 @@ static void clk_change_rate(struct clk_core *core)
 	core->rate = clk_recalc(core, best_parent_rate);
 
 	if (core->flags & CLK_SET_RATE_UNGATE) {
-		clk_core_disable_lock(core);
+		clk_core_disable_lock(core, false);
 		clk_core_unprepare(core);
 	}
 
diff --git a/include/linux/clk-provider.h b/include/linux/clk-provider.h
index 1293c38ddb7f..604cc9338465 100644
--- a/include/linux/clk-provider.h
+++ b/include/linux/clk-provider.h
@@ -115,6 +115,9 @@ struct clk_duty {
  * @disable:	Disable the clock atomically. Called with enable_lock held.
  *		This function must not sleep.
  *
+ * @disable_sync: Disable and sync the clockatomically. Called with enable_lock
+ *		held.This function must not sleep.
+ *
  * @is_enabled:	Queries the hardware to determine if the clock is enabled.
  *		This function must not sleep. Optional, if this op is not
  *		set then the enable count will be used.
@@ -238,6 +241,7 @@ struct clk_ops {
 	void		(*unprepare_unused)(struct clk_hw *hw);
 	int		(*enable)(struct clk_hw *hw);
 	void		(*disable)(struct clk_hw *hw);
+	void		(*disable_sync)(struct clk_hw *hw);
 	int		(*is_enabled)(struct clk_hw *hw);
 	void		(*disable_unused)(struct clk_hw *hw);
 	int		(*save_context)(struct clk_hw *hw);
diff --git a/include/linux/clk.h b/include/linux/clk.h
index 06f1b292f8a0..f472756310c7 100644
--- a/include/linux/clk.h
+++ b/include/linux/clk.h
@@ -664,6 +664,23 @@ int __must_check clk_bulk_enable(int num_clks,
  */
 void clk_disable(struct clk *clk);
 
+/**
+ * clk_disable_sync - inform the system when the clock source is no longer
+ *		      required.
+ * @clk: clock source
+ *
+ * Inform the system that a clock source is no longer required by
+ * a driver and is in shut down.
+ *
+ * May be called from atomic contexts.
+ *
+ * Implementation detail: if the clock source is shared between
+ * multiple drivers, clk_enable() calls must be balanced by the
+ * same number of clk_disable_sync() calls for the clock source to be
+ * disabled.
+ */
+void clk_disable_sync(struct clk *clk);
+
 /**
  * clk_bulk_disable - inform the system when the set of clks is no
  *		      longer required.
@@ -995,6 +1012,8 @@ static inline int __must_check clk_bulk_enable(int num_clks,
 
 static inline void clk_disable(struct clk *clk) {}
 
+static inline void clk_disable_sync(struct clk *clk) {}
+
 
 static inline void clk_bulk_disable(int num_clks,
 				    const struct clk_bulk_data *clks) {}
@@ -1086,6 +1105,12 @@ static inline void clk_disable_unprepare(struct clk *clk)
 	clk_unprepare(clk);
 }
 
+static inline void clk_disable_unprepare_sync(struct clk *clk)
+{
+	clk_disable_sync(clk);
+	clk_unprepare(clk);
+}
+
 static inline int __must_check
 clk_bulk_prepare_enable(int num_clks, const struct clk_bulk_data *clks)
 {
