On Wed, 2018-10-24 at 13:50 -0700, dbasehore . wrote:

On Wed, Oct 24, 2018 at 1:15 PM dbasehore . [off-list ref] wrote:

quoted

On Wed, Oct 24, 2018 at 2:51 AM Jerome Brunet [off-list ref] wrote:

quoted

On Tue, 2018-10-23 at 18:31 -0700, Derek Basehore wrote:

quoted

From: Stephen Boyd <redacted>

Enabling and preparing clocks can be written quite naturally with
recursion. We start at some point in the tree and recurse up the
tree to find the oldest parent clk that needs to be enabled or
prepared. Then we enable/prepare and return to the caller, going
back to the clk we started at and enabling/preparing along the
way.

The problem is recursion isn't great for kernel code where we
have a limited stack size. Furthermore, we may be calling this
code inside clk_set_rate() which also has recursion in it, so
we're really not looking good if we encounter a tall clk tree.

Let's create a stack instead by looping over the parent chain and
collecting clks of interest. Then the enable/prepare becomes as
simple as iterating over that list and calling enable.

Hi Derek,

What about unprepare() and disable() ?

This patch removes the recursion from the enable path but keeps it for the
disable path ... this is very odd. Assuming doing so works, It certainly makes
CCF a lot harder to understand.

What about clock protection which essentially works on the same model as prepare
and enable ?

Overall, this change does not look like something that should be merged as it
is. If you were just seeking comments, you should add the "RFC" tag to your
series.

Jerome.

quoted

Cc: Jerome Brunet <jbrunet@baylibre.com>

If you don't mind, I would prefer to get the whole series next time. It helps to
get the context.

quoted

Signed-off-by: Stephen Boyd <redacted>
Signed-off-by: Derek Basehore <redacted>
---
 drivers/clk/clk.c | 113 ++++++++++++++++++++++++++--------------------
 1 file changed, 64 insertions(+), 49 deletions(-)

diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
index af011974d4ec..95d818f5edb2 100644
--- a/drivers/clk/clk.c
+++ b/drivers/clk/clk.c

@@ -71,6 +71,8 @@ struct clk_core {
      struct hlist_head       children;
      struct hlist_node       child_node;
      struct hlist_head       clks;
+     struct list_head        prepare_list;
+     struct list_head        enable_list;
      unsigned int            notifier_count;
 #ifdef CONFIG_DEBUG_FS
      struct dentry           *dentry;

@@ -740,49 +742,48 @@ EXPORT_SYMBOL_GPL(clk_unprepare);
 static int clk_core_prepare(struct clk_core *core)
 {
      int ret = 0;
+     struct clk_core *tmp, *parent;
+     LIST_HEAD(head);

      lockdep_assert_held(&prepare_lock);

-     if (!core)
-             return 0;
+     while (core) {
+             list_add(&core->prepare_list, &head);
+             /* Stop once we see a clk that is already prepared */
+             if (core->prepare_count)
+                     break;
+             core = core->parent;
+     }

-     if (core->prepare_count == 0) {
-             ret = clk_pm_runtime_get(core);
-             if (ret)
-                     return ret;
+     list_for_each_entry_safe(core, tmp, &head, prepare_list) {
+             list_del_init(&core->prepare_list);

Is there any point in removing it from the list ?
Maybe I missed it but it does not seems useful.

Without this, we could use list_for_each_entry()

quoted

-             ret = clk_core_prepare(core->parent);
-             if (ret)
-                     goto runtime_put;
+             if (core->prepare_count == 0) {

Should we really check the count here ? You are not checking the count when the
put() counterpart is called below.

I think I accidentally messed that up when I picked up the patch.
There were some merge conflicts with the addition of the
clk_pm_runtime code.

Nevermind, this is incorrect. The clk_pm_runtime_put is within this if
statement too, so there isn't an issue here.

quoted

quoted

Since PM runtime has ref counting as well, either way would work I guess ... but
we shall be consistent

quoted

+                     ret = clk_pm_runtime_get(core);
+                     if (ret)
+                             goto err;

-             trace_clk_prepare(core);
+                     trace_clk_prepare(core);

-             if (core->ops->prepare)
-                     ret = core->ops->prepare(core->hw);
+                     if (core->ops->prepare)
+                             ret = core->ops->prepare(core->hw);

-             trace_clk_prepare_complete(core);
+                     trace_clk_prepare_complete(core);

-             if (ret)
-                     goto unprepare;
+                     if (ret) {
+                             clk_pm_runtime_put(core);
+                             goto err;
+                     }
+             }
+             core->prepare_count++;
      }

-     core->prepare_count++;
-
-     /*
-      * CLK_SET_RATE_GATE is a special case of clock protection
-      * Instead of a consumer claiming exclusive rate control, it is
-      * actually the provider which prevents any consumer from making any
-      * operation which could result in a rate change or rate glitch while
-      * the clock is prepared.
-      */
-     if (core->flags & CLK_SET_RATE_GATE)
-             clk_core_rate_protect(core);

This gets removed without anything replacing it.

is CLK_SET_RATE_GATE and clock protection support dropped after this change ?

No, I think I just accidentally removed this when resolving conflicts.

quoted

quoted

-
      return 0;
-unprepare:
-     clk_core_unprepare(core->parent);
-runtime_put:
-     clk_pm_runtime_put(core);
+err:
+     parent = core->parent;
+     list_for_each_entry_safe_continue(core, tmp, &head, prepare_list)
+             list_del_init(&core->prepare_list);
+     clk_core_unprepare(parent);

If you get here because of failure clk_pm_runtime_get(), you will unprepare a
clock which may have not been prepared first

Overall the rework of error exit path does not seem right (or necessary)

Yeah, all of this seems to just be a poor resolution of patch
conflicts on my part. Will fix.

Nevermind, that's not the case. We add the first core that has a
non-zero prepare_count to the first (or we go all the way to root).
That core can't encounter an error since those only happen in the
prepare_count == 0 case. If it's NULL, clk_core_unprepare just
returns.

Indeed, the diff is bit hard to follow and I got confused. With th patch
applied, things are more clear. Sorry about that

While correct, this code could simplified a bit

* unless the prepare_list is used anywhere without starting with a list_add(),
reseting the list pointer is not necessary. It should be possible to remove the
list_del_init(). the 'err' label becomes just 'clk_core_unprepare(core->parent)'

* rolling back change under 'if' or 'goto label' are both fine IMO. It would be
easier to follow if only one method was used inside a single function, though.

quoted

quoted

quoted

      return ret;
 }

@@ -878,37 +879,49 @@ EXPORT_SYMBOL_GPL(clk_disable);
 static int clk_core_enable(struct clk_core *core)
 {
      int ret = 0;
+     struct clk_core *tmp, *parent;
+     LIST_HEAD(head);

      lockdep_assert_held(&enable_lock);

-     if (!core)
-             return 0;
-
-     if (WARN(core->prepare_count == 0,
-         "Enabling unprepared %s\n", core->name))
-             return -ESHUTDOWN;
+     while (core) {
+             list_add(&core->enable_list, &head);
+             /* Stop once we see a clk that is already enabled */
+             if (core->enable_count)
+                     break;
+             core = core->parent;
+     }

-     if (core->enable_count == 0) {
-             ret = clk_core_enable(core->parent);
+     list_for_each_entry_safe(core, tmp, &head, enable_list) {
+             list_del_init(&core->enable_list);

-             if (ret)
-                     return ret;
+             if (WARN_ON(core->prepare_count == 0)) {
+                     ret = -ESHUTDOWN;
+                     goto err;
+             }

-             trace_clk_enable_rcuidle(core);
+             if (core->enable_count == 0) {
+                     trace_clk_enable_rcuidle(core);

-             if (core->ops->enable)
-                     ret = core->ops->enable(core->hw);
+                     if (core->ops->enable)
+                             ret = core->ops->enable(core->hw);

-             trace_clk_enable_complete_rcuidle(core);
+                     trace_clk_enable_complete_rcuidle(core);

-             if (ret) {
-                     clk_core_disable(core->parent);
-                     return ret;
+                     if (ret)
+                             goto err;
              }
+
+             core->enable_count++;
      }

-     core->enable_count++;
      return 0;
+err:
+     parent = core->parent;
+     list_for_each_entry_safe_continue(core, tmp, &head, enable_list)
+             list_del_init(&core->enable_list);
+     clk_core_disable(parent);
+     return ret;
 }

 static int clk_core_enable_lock(struct clk_core *core)

@@ -3281,6 +3294,8 @@ struct clk *clk_register(struct device *dev, struct clk_hw *hw)
      core->num_parents = hw->init->num_parents;
      core->min_rate = 0;
      core->max_rate = ULONG_MAX;
+     INIT_LIST_HEAD(&core->prepare_list);
+     INIT_LIST_HEAD(&core->enable_list);
      hw->core = core;

      /* allocate local copy in case parent_names is __initdata */