This can be useful when clock core wants to enable/disable clocks.
Then we don't have to convert the struct clk_core to struct clk to call
clk_enable/clk_disable which is a bit un-align with exist using.

And after introduce clk_core_{enable|disable}_lock, we can refine
clk_eanble and clk_disable a bit.

As well as clk_core_{enable|disable}_lock, we also added
clk_core_{prepare|unprepare}_lock and clk_core_prepare_enable/
clk_core_unprepare_disable for clock core to easily use.

Cc: Mike Turquette <mturque...@linaro.org>
Cc: Stephen Boyd <sb...@codeaurora.org>
Signed-off-by: Dong Aisheng <aisheng.d...@freescale.com>
---
 drivers/clk/clk.c | 85 +++++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 63 insertions(+), 22 deletions(-)

diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
index 4c7f7b2..c2310d5 100644
--- a/drivers/clk/clk.c
+++ b/drivers/clk/clk.c
@@ -583,6 +583,13 @@ static void clk_core_unprepare(struct clk_core *core)
        clk_core_unprepare(core->parent);
 }
 
+static void clk_core_unprepare_lock(struct clk_core *core)
+{
+       clk_prepare_lock();
+       clk_core_unprepare(core);
+       clk_prepare_unlock();
+}
+
 /**
  * clk_unprepare - undo preparation of a clock source
  * @clk: the clk being unprepared
@@ -599,9 +606,7 @@ void clk_unprepare(struct clk *clk)
        if (IS_ERR_OR_NULL(clk))
                return;
 
-       clk_prepare_lock();
-       clk_core_unprepare(clk->core);
-       clk_prepare_unlock();
+       clk_core_unprepare_lock(clk->core);
 }
 EXPORT_SYMBOL_GPL(clk_unprepare);
 
@@ -637,6 +642,17 @@ static int clk_core_prepare(struct clk_core *core)
        return 0;
 }
 
+static int clk_core_prepare_lock(struct clk_core *core)
+{
+       int ret;
+
+       clk_prepare_lock();
+       ret = clk_core_prepare(core);
+       clk_prepare_unlock();
+
+       return ret;
+}
+
 /**
  * clk_prepare - prepare a clock source
  * @clk: the clk being prepared
@@ -651,16 +667,10 @@ static int clk_core_prepare(struct clk_core *core)
  */
 int clk_prepare(struct clk *clk)
 {
-       int ret;
-
        if (!clk)
                return 0;
 
-       clk_prepare_lock();
-       ret = clk_core_prepare(clk->core);
-       clk_prepare_unlock();
-
-       return ret;
+       return clk_core_prepare_lock(clk->core);
 }
 EXPORT_SYMBOL_GPL(clk_prepare);
 
@@ -687,6 +697,15 @@ static void clk_core_disable(struct clk_core *core)
        clk_core_disable(core->parent);
 }
 
+static void clk_core_disable_lock(struct clk_core *core)
+{
+       unsigned long flags;
+
+       flags = clk_enable_lock();
+       clk_core_disable(core);
+       clk_enable_unlock(flags);
+}
+
 /**
  * clk_disable - gate a clock
  * @clk: the clk being gated
@@ -701,14 +720,10 @@ static void clk_core_disable(struct clk_core *core)
  */
 void clk_disable(struct clk *clk)
 {
-       unsigned long flags;
-
        if (IS_ERR_OR_NULL(clk))
                return;
 
-       flags = clk_enable_lock();
-       clk_core_disable(clk->core);
-       clk_enable_unlock(flags);
+       clk_core_disable_lock(clk->core);
 }
 EXPORT_SYMBOL_GPL(clk_disable);
 
@@ -747,6 +762,18 @@ static int clk_core_enable(struct clk_core *core)
        return 0;
 }
 
+static int clk_core_enable_lock(struct clk_core *core)
+{
+       unsigned long flags;
+       int ret;
+
+       flags = clk_enable_lock();
+       ret = clk_core_enable(core);
+       clk_enable_unlock(flags);
+
+       return ret;
+}
+
 /**
  * clk_enable - ungate a clock
  * @clk: the clk being ungated
@@ -762,19 +789,33 @@ static int clk_core_enable(struct clk_core *core)
  */
 int clk_enable(struct clk *clk)
 {
-       unsigned long flags;
-       int ret;
-
        if (!clk)
                return 0;
 
-       flags = clk_enable_lock();
-       ret = clk_core_enable(clk->core);
-       clk_enable_unlock(flags);
+       return clk_core_enable_lock(clk->core);
+}
+EXPORT_SYMBOL_GPL(clk_enable);
+
+static int clk_core_prepare_enable(struct clk_core *core)
+{
+       int ret;
+
+       ret = clk_core_prepare_lock(core);
+       if (ret)
+               return ret;
+
+       ret = clk_core_enable_lock(core);
+       if (ret)
+               clk_core_unprepare_lock(core);
 
        return ret;
 }
-EXPORT_SYMBOL_GPL(clk_enable);
+
+static void clk_core_disable_unprepare(struct clk_core *core)
+{
+       clk_core_disable_lock(core);
+       clk_core_unprepare_lock(core);
+}
 
 static int clk_core_round_rate_nolock(struct clk_core *core,
                                      struct clk_rate_request *req)
-- 
1.9.1

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majord...@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

Reply via email to