clk: implement remuxing during set_rate
Subsystems (2)
v2 cover clk: implement remuxing during set_rate
This patchset adds support for automatic selection of the best parent for a clock mux, i.e. the one which can provide the closest clock rate to that requested. It can be controlled by a new CLK_SET_RATE_REMUX flag so that it doesn't happen unless explicitly allowed.
This works by way of adding a new op, determine_rate, similar to round_rate but with an extra parameter to allow the clock driver to optionally select a different parent clock. This is used in clk_calc_new_rates to decide whether to initiate a set_parent operation.
Changes in v2:
I've moved the mux determine_rate implementation into a core helper, but I haven't pushed it fully into the core, as I think it just wouldn't work correctly for more complex clocks, e.g. if you (theoretically) had a combined mux and divide, you'd want to intercept the determine_rate and ask for a larger rate from the parent clocks, then return the divided rate. This should be possible by wrapping the mux determine_rate helper.
Patch 1 still exports the __clk_get_parent_by_index as it seems like it might be a useful thing for clock implementations to have access to if they ever wanted to do something more fancy with changing clock parents.
I haven't made any attempt to implement the atomic set_parent+set_rate as I don't have hardware that could take proper advantage of it, but it shouldn't be too difficult for others to implement if they wanted since they're fairly close to one another (in clk_change_rate()).
* switched to using new determine_rate op rather than adding an argument to round_rate.
* moved mux implementation into a single helper which should be usable from more complex clocks which can mux.
* rewrite main implementation so that no changes are made until after the PRE notifications have been sent, and in a way that should ensure correct notifications without duplicates, and I think should be safe in the event of a notification failing.
* various tidy ups and fixes.
James Hogan (3):
clk: abstract parent cache
clk: add support for clock reparent on set_rate
clk: clk-mux: implement remuxing on set_rate
Documentation/clk.txt | 4 + drivers/clk/clk-mux.c | 1 + drivers/clk/clk.c | 216 +++++++++++++++++++++++++++++++++---------- include/linux/clk-private.h | 2 + include/linux/clk-provider.h | 12 +++ 5 files changed, 185 insertions(+), 50 deletions(-)
Signature · 1 line
1.8.1.2
PATCH v2 1/3 clk: abstract parent cache
Abstract access to the clock parent cache by defining __clk_get_parent_by_index(clk, index). This allows access to parent clocks from clock drivers.
--- drivers/clk/clk.c | 21 ++++++++++++++------- include/linux/clk-provider.h | 1 + 2 files changed, 15 insertions(+), 7 deletions(-)
drivers/clk/clk.c +14 -7
@@ -415,6 +415,19 @@ struct clk *__clk_get_parent(struct clk *clk)return !clk ?NULL : clk->parent; } +struct clk *__clk_get_parent_by_index (struct clk *clk,u8 index) +{ +if (!clk || index >= clk->num_parents) +return NULL ; +else if (!clk->parents) +return __clk_lookup (clk->parent_names[index]); +else if (!clk->parents[index]) +return clk->parents[index] = +__clk_lookup (clk->parent_names[index]); +else +return clk->parents[index]; +} +unsigned int __clk_get_enable_count (struct clk *clk) {return !clk ?0 : clk->enable_count;
@@ -1150,13 +1163,7 @@ static struct clk *__clk_init_parent(struct clk *clk)kzalloc ((sizeof (struct clk *) * clk->num_parents),GFP_KERNEL ); -if (!clk->parents) - ret =__clk_lookup (clk->parent_names[index]); -else if (!clk->parents[index]) - ret = clk->parents[index] = -__clk_lookup (clk->parent_names[index]); -else - ret = clk->parents[index]; + ret =__clk_get_parent_by_index (clk, index); out:return ret;
include/linux/clk-provider.h +1 -0
@@ -347,6 +347,7 @@ const char *__clk_get_name(struct clk *clk);struct clk_hw *__clk_get_hw (struct clk *clk);u8 __clk_get_num_parents (struct clk *clk);struct clk *__clk_get_parent (struct clk *clk); +struct clk *__clk_get_parent_by_index (struct clk *clk,u8 index);unsigned int __clk_get_enable_count (struct clk *clk);unsigned int __clk_get_prepare_count (struct clk *clk);unsigned long __clk_get_rate (struct clk *clk);
Signature · 1 line
1.8.1.2
Re: [PATCH v2 1/3] clk: abstract parent cache
Quoting James Hogan (2013-04-19 09:28:22)
Quoted 15 lines
Abstract access to the clock parent cache by defining
__clk_get_parent_by_index(clk, index). This allows access to parent clocks from clock drivers.Signed-off-by James Hogan <[email protected]>--- drivers/clk/clk.c | 21 ++++++++++++++------- include/linux/clk-provider.h | 1 + 2 files changed, 15 insertions(+), 7 deletions(-)drivers/clk/clk.c +0
-0
drivers/clk/clk.c struct clk *__clk_get_parent(struct clk *clk) · line 418
Quoted 4 lines
drivers/clk/clk.c +1
-0@@ -415,6 +415,19 @@ struct clk *__clk_get_parent(struct clk *clk)return !clk ?NULL : clk->parent; } +struct clk *__clk_get_parent_by_index (struct clk *clk,u8 index)
This looks good, but in the next version can you remove the double underscore? I'm getting rid of a lot of those double underscore helpers now that the reentrancy patch is merged and I think this is a reasonable top-level API for a clock provider to have.
Thanks,
Mike
Quoted 44 lines
drivers/clk/clk.c +13
-7+{ +if (!clk || index >= clk->num_parents) +return NULL ; +else if (!clk->parents) +return __clk_lookup (clk->parent_names[index]); +else if (!clk->parents[index]) +return clk->parents[index] = +__clk_lookup (clk->parent_names[index]); +else +return clk->parents[index]; +} +unsigned int __clk_get_enable_count (struct clk *clk) {return !clk ?0 : clk->enable_count;@@ -1150,13 +1163,7 @@ static struct clk *__clk_init_parent(struct clk *clk)kzalloc ((sizeof (struct clk *) * clk->num_parents),GFP_KERNEL ); -if (!clk->parents) - ret =__clk_lookup (clk->parent_names[index]); -else if (!clk->parents[index]) - ret = clk->parents[index] = -__clk_lookup (clk->parent_names[index]); -else - ret = clk->parents[index]; + ret =__clk_get_parent_by_index (clk, index); out:return ret;include/linux/clk-provider.h +1
-0@@ -347,6 +347,7 @@ const char *__clk_get_name(struct clk *clk);struct clk_hw *__clk_get_hw (struct clk *clk);u8 __clk_get_num_parents (struct clk *clk);struct clk *__clk_get_parent (struct clk *clk); +struct clk *__clk_get_parent_by_index (struct clk *clk,u8 index);unsigned int __clk_get_enable_count (struct clk *clk);unsigned int __clk_get_prepare_count (struct clk *clk);unsigned long __clk_get_rate (struct clk *clk);Signature · 1 line
1.8.1.2
PATCH v2 2/3 clk: add support for clock reparent on set_rate
In reply to James HoganAdd core support to allow clock implementations to select the best parent clock when rounding a rate, e.g. the one which can provide the closest clock rate to that requested. This is by way of adding a new clock op, determine_rate(), which is like round_rate() but has an extra parameter to allow the clock implementation to optionally select a different parent clock. The core then takes care of reparenting the clock when setting the rate.
The parent change takes place with the help of two new private data members. struct clk::new_parent specifies a clock's new parent (NULL indicates no change), and struct clk::new_child specifies a clock's new child (whose new_parent member points back to it). The purpose of these are to allow correct walking of the future tree for notifications prior to actually reparenting any clocks, specifically to skip child clocks who are being reparented to another clock (they will be notified via the new parent), and to include any new child clock. These pointers are set by clk_calc_subtree(), and the new_child pointer gets cleared when a child is actually reparented to avoid duplicate POST_RATE_CHANGE notifications.
Each place where round_rate() is called, determine_rate is checked first and called in preference, passing NULL to the new parent argument if not needed (e.g. in __clk_round_rate). This restructures a few of the call sites to simplify the logic into if/else blocks.
A new __clk_set_parent_no_recalc() is created similar to clk_set_parent() but without calling __clk_recalc_rates(). This is for clk_change_rate() to use, where rate recalculation and notifications are already handled.
--- Documentation/clk.txt | 4 ++ drivers/clk/clk.c | 146 ++++++++++++++++++++++++++++++------------- include/linux/clk-private.h | 2 + include/linux/clk-provider.h | 7 +++ 4 files changed, 116 insertions(+), 43 deletions(-)
Documentation/clk.txt +4 -0
@@ -70,6 +70,10 @@ the operations defined in clk.h: unsigned long parent_rate); long (*round_rate)(struct clk_hw *hw, unsigned long, unsigned long *); + long (*determine_rate)(struct clk_hw *hw, + unsigned long rate, + unsigned long *best_parent_rate, + struct clk **best_parent_clk); int (*set_parent)(struct clk_hw *hw, u8 index); u8 (*get_parent)(struct clk_hw *hw); int (*set_rate)(struct clk_hw *hw, unsigned long);
drivers/clk/clk.c +103 -43
247 lines not on this page · raw message
include/linux/clk-private.h +2 -0
@@ -35,6 +35,8 @@ struct clk {u8 num_parents;unsigned long rate;unsigned long new_rate; +struct clk *new_parent; +struct clk *new_child;unsigned long flags;unsigned int enable_count;unsigned int prepare_count;
include/linux/clk-provider.h +7 -0
@@ -71,6 +71,10 @@ struct clk_hw;* @round_rate: Given a target rate as input, returns the closest rate actually * supported by the clock. * +* @determine_rate: Given a target rate as input, returns the closest rate +* actually supported by the clock, and optionally the parent clock +* that should be used to provide the clock rate. +* * @get_parent: Queries the hardware to determine the parent of a clock. The * return value is a u8 which specifies the index corresponding to * the parent clock. This index can be applied to either the
@@ -116,6 +120,9 @@ struct clk_ops { unsigned long parent_rate);long (*round_rate)(struct clk_hw *hw,unsigned long ,unsigned long *); +long (*determine_rate)(struct clk_hw *hw,unsigned long rate, +unsigned long *best_parent_rate, +struct clk **best_parent_clk);int (*set_parent)(struct clk_hw *hw,u8 index);u8 (*get_parent)(struct clk_hw *hw); int (*set_rate)(struct clk_hw *hw, unsigned long,
Signature · 1 line
1.8.1.2
Re: [PATCH v2 2/3] clk: add support for clock reparent on set_rate
Quoted 25 lines · James Hogan
Add core support to allow clock implementations to select the best parent clock when rounding a rate, e.g. the one which can provide the closest clock rate to that requested. This is by way of adding a new clock op,
determine_rate(), which is likeround_rate()but has an extra parameter to allow the clock implementation to optionally select a different parent clock. The core then takes care of reparenting the clock when setting the rate.The parent change takes place with the help of two new private data members. struct
clk::new_parentspecifies a clock's new parent (NULL indicates no change), and structclk::new_childspecifies a clock's new child (whosenew_parentmember points back to it). The purpose of these are to allow correct walking of the future tree for notifications prior to actually reparenting any clocks, specifically to skip child clocks who are being reparented to another clock (they will be notified via the new parent), and to include any new child clock. These pointers are set byclk_calc_subtree(), and thenew_childpointer gets cleared when a child is actually reparented to avoid duplicatePOST_RATE_CHANGEnotifications.Each place where
round_rate()is called,determine_rateis checked first and called in preference, passing NULL to the new parent argument if not needed (e.g. in__clk_round_rate). This restructures a few of the call sites to simplify the logic into if/else blocks.
Quoted 6 lines
A new
__clk_set_parent_no_recalc()is created similar toclk_set_parent()but without calling__clk_recalc_rates(). This is forclk_change_rate()to use, where rate recalculation and notifications are already handled.Signed-off-by James Hogan <[email protected]>
I believe we'll need to update the check in __clk_init() to allow you to have either a .round_rate or a .determine_rate op if you have a .recalc_rate op. Right now it fails to register the clock and then oopses later on while setting up clock debugfs.
Here's a (probably whitespace damaged) patch for the first one.
----8<-----
drivers/clk/clk.c +2 -2
@@ -1668,8 +1668,8 @@ int __clk_init(struct device *dev, struct clk *clk)/* check that clk_ops are sane. See Documentation/clk.txt */ if (clk->ops->set_rate && - !(clk->ops->round_rate && clk->ops->recalc_rate)) { -pr_warning ("%s: %s must implement .round_rate & .recalc_rate\n" , + !((clk->ops->round_rate || clk->ops->determine_rate) && clk->ops->recalc_rate)) { +pr_warning ("%s: %s must implement .round_rate or .determine_rate in addition to .recalc_rate\n" , __func__, clk->name); ret = -EINVAL ; goto out;
Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, hosted by The Linux Foundation
Re: [PATCH v2 2/3] clk: add support for clock reparent on set_rate
Quoted 6 lines · Stephen Boyd
I believe we'll need to update the check in
__clk_init()to allow you to have either a .round_rate or a .determine_rate op if you have a .recalc_rate op. Right now it fails to register the clock and then oopses later on while setting up clock debugfs.Here's a (probably whitespace damaged) patch for the first one.
Thanks, I'll incorporate that.
Cheers
James
Re: [PATCH v2 2/3] clk: add support for clock reparent on set_rate
In reply to James HoganQuoting James Hogan (2013-04-19 09:28:23)
Quoted 8 lines
Add core support to allow clock implementations to select the best parent clock when rounding a rate, e.g. the one which can provide the closest clock rate to that requested. This is by way of adding a new clock op,
determine_rate(), which is likeround_rate()but has an extra parameter to allow the clock implementation to optionally select a different parent clock. The core then takes care of reparenting the clock when setting the rate.
Hi James,
Can you rebase this onto -rc1? It does not apply cleanly.
Thanks,
Mike
Quoted 349 lines
The parent change takes place with the help of two new private data members. struct
clk::new_parentspecifies a clock's new parent (NULL indicates no change), and structclk::new_childspecifies a clock's new child (whosenew_parentmember points back to it). The purpose of these are to allow correct walking of the future tree for notifications prior to actually reparenting any clocks, specifically to skip child clocks who are being reparented to another clock (they will be notified via the new parent), and to include any new child clock. These pointers are set byclk_calc_subtree(), and thenew_childpointer gets cleared when a child is actually reparented to avoid duplicatePOST_RATE_CHANGEnotifications.Each place where
round_rate()is called,determine_rateis checked first and called in preference, passing NULL to the new parent argument if not needed (e.g. in__clk_round_rate). This restructures a few of the call sites to simplify the logic into if/else blocks.A new
__clk_set_parent_no_recalc()is created similar toclk_set_parent()but without calling__clk_recalc_rates(). This is forclk_change_rate()to use, where rate recalculation and notifications are already handled.Signed-off-by James Hogan <[email protected]>--- Documentation/clk.txt | 4 ++ drivers/clk/clk.c | 146 ++++++++++++++++++++++++++++++------------- include/linux/clk-private.h | 2 + include/linux/clk-provider.h | 7 +++ 4 files changed, 116 insertions(+), 43 deletions(-)Documentation/clk.txt +4
-0@@ -70,6 +70,10 @@ the operations defined in clk.h: unsigned long parent_rate); long (*round_rate)(struct clk_hw *hw, unsigned long, unsigned long *); + long (*determine_rate)(struct clk_hw *hw, + unsigned long rate, + unsigned long *best_parent_rate, + struct clk **best_parent_clk); int (*set_parent)(struct clk_hw *hw, u8 index); u8 (*get_parent)(struct clk_hw *hw); int (*set_rate)(struct clk_hw *hw, unsigned long);drivers/clk/clk.c +103
-43@@ -27,6 +27,8 @@ static HLIST_HEAD(clk_root_list);static HLIST_HEAD (clk_orphan_list);static LIST_HEAD (clk_notifier_list); +static int __clk_set_parent_no_recalc (struct clk *clk,struct clk *parent); +/*** debugfs support ***/ #ifdef CONFIG_COMMON_CLK_DEBUG @@ -727,17 +729,20 @@ unsigned long __clk_round_rate(struct clk *clk, unsigned long rate)if (!clk)return 0 ; -if (!clk->ops->round_rate) { -if (clk->flags &CLK_SET_RATE_PARENT ) -return __clk_round_rate (clk->parent, rate); -else -return clk->rate; - }if (clk->parent) parent_rate = clk->parent->rate; -return clk->ops->round_rate (clk->hw, rate, &parent_rate); +if (clk->ops->determine_rate) +return clk->ops->determine_rate (clk->hw, rate, &parent_rate, +NULL ); +else if (clk->ops->round_rate) +return clk->ops->round_rate (clk->hw, rate, &parent_rate); +else if (clk->flags &CLK_SET_RATE_PARENT ) +return __clk_round_rate (clk->parent, rate); +else +return clk->rate; + }/** @@ -906,18 +911,23 @@ out:return ret; } -static void clk_calc_subtree (struct clk *clk,unsigned long new_rate) +static void clk_calc_subtree (struct clk *clk,unsigned long new_rate, +struct clk *new_parent) {struct clk *child; clk->new_rate = new_rate; + clk->new_parent = new_parent; + clk->new_child =NULL ; +if (new_parent && new_parent != clk->parent) + new_parent->new_child = clk;hlist_for_each_entry (child, &clk->children, child_node) {if (child->ops->recalc_rate) child->new_rate = child->ops->recalc_rate (child->hw, new_rate);else child->new_rate = new_rate; -clk_calc_subtree (child, child->new_rate); +clk_calc_subtree (child, child->new_rate,NULL ); } }@@ -928,6 +938,7 @@ static void clk_calc_subtree(struct clk *clk, unsigned long new_rate)static struct clk *clk_calc_new_rates (struct clk *clk,unsigned long rate) {struct clk *top = clk; +struct clk *old_parent, *parent;unsigned long best_parent_rate =0 ;unsigned long new_rate;@@ -936,42 +947,43 @@ static struct clk *clk_calc_new_rates(struct clk *clk, unsigned long rate)return NULL ;/* save parent rate, if it exists */ -if (clk->parent) - best_parent_rate = clk->parent->rate; - -/* never propagate up to the parent */ -if (!(clk->flags &CLK_SET_RATE_PARENT )) { -if (!clk->ops->round_rate) { - clk->new_rate = clk->rate; -return NULL ; - } - new_rate = clk->ops->round_rate (clk->hw, rate, &best_parent_rate); + parent = old_parent = clk->parent; +if (parent) + best_parent_rate = parent->rate; + +/* find the closest rate and parent clk/rate */ +if (clk->ops->determine_rate) { + new_rate = clk->ops->determine_rate (clk->hw, rate, + &best_parent_rate, + &parent); + }else if (clk->ops->round_rate) { + new_rate = clk->ops->round_rate (clk->hw, rate, + &best_parent_rate); + }else if (!parent || !(clk->flags &CLK_SET_RATE_PARENT )) { +/* pass-through clock without adjustable parent */ + clk->new_rate = clk->rate; +return NULL ; + }else { +/* pass-through clock with adjustable parent */ + top =clk_calc_new_rates (parent, rate); + new_rate = parent->new_rate; goto out; } -/* need clk->parent from here on out */ -if (!clk->parent) { -pr_debug ("%s: %s has NULL parent\n" , __func__, clk->name); +/* some clocks must be gated to change parent */ +if (parent != old_parent && + (clk->flags &CLK_SET_PARENT_GATE ) && clk->prepare_count) { +pr_debug ("%s: %s not gated but wants to reparent\n" , + __func__, clk->name);return NULL ; } -if (!clk->ops->round_rate) { - top =clk_calc_new_rates (clk->parent, rate); - new_rate = clk->parent->new_rate; - - goto out; - } - - new_rate = clk->ops->round_rate (clk->hw, rate, &best_parent_rate); - -if (best_parent_rate != clk->parent->rate) { - top =clk_calc_new_rates (clk->parent, best_parent_rate); - - goto out; - } +if ((clk->flags &CLK_SET_RATE_PARENT ) && parent && + best_parent_rate != parent->rate) + top =clk_calc_new_rates (parent, best_parent_rate); out: -clk_calc_subtree (clk, new_rate); +clk_calc_subtree (clk, new_rate, parent);return top; }@@ -983,7 +995,7 @@ out:*/ static struct clk *clk_propagate_rate_change (struct clk *clk,unsigned long event) { -struct clk *child, *fail_clk =NULL ; +struct clk *child, *tmp_clk, *fail_clk =NULL ;int ret =NOTIFY_DONE ;if (clk->rate == clk->new_rate)@@ -996,9 +1008,19 @@ static struct clk *clk_propagate_rate_change(struct clk *clk, unsigned long even }hlist_for_each_entry (child, &clk->children, child_node) { - clk =clk_propagate_rate_change (child, event); -if (clk) - fail_clk = clk; +/* Skip children who will be reparented to another clock */ +if (child->new_parent && child->new_parent != clk) +continue ; + tmp_clk =clk_propagate_rate_change (child, event); +if (tmp_clk) + fail_clk = tmp_clk; + } + +/* handle the new child who might not be in clk->children yet */ +if (clk->new_child) { + tmp_clk =clk_propagate_rate_change (clk->new_child, event); +if (tmp_clk) + fail_clk = tmp_clk; }return fail_clk;@@ -1016,6 +1038,10 @@ static void clk_change_rate(struct clk *clk) old_rate = clk->rate; +/* set parent */ +if (clk->new_parent && clk->new_parent != clk->parent) +__clk_set_parent_no_recalc (clk, clk->new_parent); +if (clk->parent) best_parent_rate = clk->parent->rate;@@ -1030,8 +1056,15 @@ static void clk_change_rate(struct clk *clk)if (clk->notifier_count && old_rate != clk->rate)__clk_notify (clk,POST_RATE_CHANGE , old_rate, clk->rate); -hlist_for_each_entry (child, &clk->children, child_node) +hlist_for_each_entry (child, &clk->children, child_node) { +/* Skip children who will be reparented to another clock */ +if (child->new_parent && child->new_parent != clk) +continue ;clk_change_rate (child); + } + +if (clk->new_child) +clk_change_rate (clk->new_child); }/** @@ -1169,7 +1202,7 @@ out:return ret; } -void __clk_reparent (struct clk *clk,struct clk *new_parent) +void __clk_reparent_no_recalc (struct clk *clk,struct clk *new_parent) {#ifdef CONFIG_COMMON_CLK_DEBUG struct dentry *d;@@ -1179,6 +1212,9 @@ void __clk_reparent(struct clk *clk, struct clk *new_parent)if (!clk || !new_parent)return ; +if (new_parent->new_child == clk) + new_parent->new_child =NULL ; +hlist_del (&clk->child_node);if (new_parent)@@ -1206,6 +1242,11 @@ out:#endif clk->parent = new_parent; +} + +void __clk_reparent (struct clk *clk,struct clk *new_parent) +{ +__clk_reparent_no_recalc (clk, new_parent);__clk_recalc_rates (clk,POST_RATE_CHANGE ); }@@ -1270,6 +1311,25 @@ out:return ret; } +static int __clk_set_parent_no_recalc (struct clk *clk,struct clk *parent) +{ +int ret =0 ; + +if (clk->parent == parent) + goto out; + +/* only re-parent if the clock is not in use */ + ret =__clk_set_parent (clk, parent); +if (ret) + goto out; + +/* reparent, but don't propagate rate recalculation downstream */ +__clk_reparent_no_recalc (clk, parent); + +out: +return ret; +} +/** * clk_set_parent - switch the parent of a mux clk * @clk: the mux clk whose input we are switching include/linux/clk-private.h +2
-0@@ -35,6 +35,8 @@ struct clk {u8 num_parents;unsigned long rate;unsigned long new_rate; +struct clk *new_parent; +struct clk *new_child;unsigned long flags;unsigned int enable_count;unsigned int prepare_count;include/linux/clk-provider.h +7
-0@@ -71,6 +71,10 @@ struct clk_hw;* @round_rate: Given a target rate as input, returns the closest rate actually * supported by the clock. * +* @determine_rate: Given a target rate as input, returns the closest rate +* actually supported by the clock, and optionally the parent clock +* that should be used to provide the clock rate. +* * @get_parent: Queries the hardware to determine the parent of a clock. The * return value is a u8 which specifies the index corresponding to * the parent clock. This index can be applied to either the @@ -116,6 +120,9 @@ struct clk_ops { unsigned long parent_rate);long (*round_rate)(struct clk_hw *hw,unsigned long ,unsigned long *); +long (*determine_rate)(struct clk_hw *hw,unsigned long rate, +unsigned long *best_parent_rate, +struct clk **best_parent_clk);int (*set_parent)(struct clk_hw *hw,u8 index);u8 (*get_parent)(struct clk_hw *hw); int (*set_rate)(struct clk_hw *hw, unsigned long,Signature · 1 line
1.8.1.2
Re: [PATCH v2 2/3] clk: add support for clock reparent on set_rate
Quoted 10 lines · Mike Turquette
Quoting James Hogan (2013-04-19 09:28:23)
Quoted 8 lines
Add core support to allow clock implementations to select the best parent clock when rounding a rate, e.g. the one which can provide the closest clock rate to that requested. This is by way of adding a new clock op,
determine_rate(), which is likeround_rate()but has an extra parameter to allow the clock implementation to optionally select a different parent clock. The core then takes care of reparenting the clock when setting the rate.
Quoted 3 lines
Hi James,
Can you rebase this onto -rc1? It does not apply cleanly.
Hi Mike,
Sure, I rebased onto clk-next the other day so I'll update to rc1 and resubmit tomorrow.
Cheers
James
PATCH v2 3/3 clk: clk-mux: implement remuxing on set_rate
In reply to James HoganAdd a new clock flag called CLK_SET_RATE_REMUX to indicate that the clock can have it's parent changed automatically in response to a set_rate.
Implement clk-mux remuxing if the CLK_SET_RATE_REMUX flag is set. This implements determine_rate for clk-mux to propagate to each parent and to choose the best one (like clk-divider this chooses the parent which provides the fastest rate <= the requested rate).
The determine_rate op is implemented as a core helper function so that it can be easily used by more complex clocks which incorporate muxes.
--- drivers/clk/clk-mux.c | 1 + drivers/clk/clk.c | 49 ++++++++++++++++++++++++++++++++++++++++++++ include/linux/clk-provider.h | 4 ++++ 3 files changed, 54 insertions(+)
drivers/clk/clk-mux.c +1 -0
@@ -85,6 +85,7 @@ static int clk_mux_set_parent(struct clk_hw *hw, u8 index)const struct clk_ops clk_mux_ops = { .get_parent = clk_mux_get_parent, .set_parent = clk_mux_set_parent, + .determine_rate = __clk_mux_determine_rate, };EXPORT_SYMBOL_GPL (clk_mux_ops);
drivers/clk/clk.c +49 -0
55 lines not on this page · raw message
include/linux/clk-provider.h +4 -0
@@ -27,6 +27,7 @@#define CLK_IS_ROOT BIT(4)/* root clk, has no parent */ #define CLK_IS_BASIC BIT(5)/* Basic clk, can't do a to_clk_foo() */ #define CLK_GET_RATE_NOCACHE BIT(6)/* do not use the cached clk rate */ +#define CLK_SET_RATE_REMUX BIT(7)/* find best parent for rate change */ struct clk_hw ;
@@ -361,6 +362,9 @@ unsigned long __clk_get_rate(struct clk *clk);unsigned long __clk_get_flags (struct clk *clk);bool __clk_is_enabled (struct clk *clk);struct clk *__clk_lookup (const char *name); +long __clk_mux_determine_rate (struct clk_hw *hw,unsigned long rate, +unsigned long *best_parent_rate, +struct clk **best_parent_p);/* * FIXME clock api without lock protection
Signature · 1 line
1.8.1.2
Quoted 9 lines · James Hogan
This patchset adds support for automatic selection of the best parent for a clock mux, i.e. the one which can provide the closest clock rate to that requested. It can be controlled by a new
CLK_SET_RATE_REMUXflag so that it doesn't happen unless explicitly allowed.This works by way of adding a new op,
determine_rate, similar toround_ratebut with an extra parameter to allow the clock driver to optionally select a different parent clock. This is used inclk_calc_new_ratesto decide whether to initiate aset_parentoperation.
Which tree is this based on? I get failures with git am on patch 2.
Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, hosted by The Linux Foundation
Quoted 6 lines · Stephen Boyd
Quoted 5 lines · James Hogan
This patchset adds support for automatic selection of the best parent for a clock mux, i.e. the one which can provide the closest clock rate to that requested. It can be controlled by a new
CLK_SET_RATE_REMUXflag so that it doesn't happen unless explicitly allowed.
Quoted 7 lines
Quoted 4 lines
This works by way of adding a new op,
determine_rate, similar toround_ratebut with an extra parameter to allow the clock driver to optionally select a different parent clock. This is used inclk_calc_new_ratesto decide whether to initiate aset_parentoperation.Which tree is this based on? I get failures with git am on patch 2.
Mike's clk-for-3.10 branch.
-Saravana
Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, hosted by The Linux Foundation
Quoted 6 lines · Stephen Boyd
Quoted 5 lines · James Hogan
This patchset adds support for automatic selection of the best parent for a clock mux, i.e. the one which can provide the closest clock rate to that requested. It can be controlled by a new
CLK_SET_RATE_REMUXflag so that it doesn't happen unless explicitly allowed.
Quoted 7 lines
Quoted 4 lines
This works by way of adding a new op,
determine_rate, similar toround_ratebut with an extra parameter to allow the clock driver to optionally select a different parent clock. This is used inclk_calc_new_ratesto decide whether to initiate aset_parentoperation.Which tree is this based on? I get failures with git am on patch 2.
It was based on v3.9-rc4.
Cheers
James
Quoted 7 lines · James Hogan
Quoted 6 lines · Stephen Boyd
Quoted 5 lines · James Hogan
This patchset adds support for automatic selection of the best parent for a clock mux, i.e. the one which can provide the closest clock rate to that requested. It can be controlled by a new
CLK_SET_RATE_REMUXflag so that it doesn't happen unless explicitly allowed.
Quoted 8 lines
Quoted 6 lines
Quoted 4 lines
This works by way of adding a new op,
determine_rate, similar toround_ratebut with an extra parameter to allow the clock driver to optionally select a different parent clock. This is used inclk_calc_new_ratesto decide whether to initiate aset_parentoperation.Which tree is this based on? I get failures with git am on patch 2.
It was based on v3.9-rc4.
Thanks. Would it be possible for you to update to Mike's for-next branch? I've done the rebase myself for now and it seems to work well enough. I'll need to add the set_rate_and_parent() op on top.
Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, hosted by The Linux Foundation
Quoted 11 lines · Stephen Boyd
Quoted 5 lines · James Hogan
Quoted 2 lines · Stephen Boyd
Which tree is this based on? I get failures with git am on patch 2.
It was based on v3.9-rc4.
Thanks. Would it be possible for you to update to Mike's for-next branch? I've done the rebase myself for now and it seems to work well enough. I'll need to add the
set_rate_and_parent()op on top.
Yes, I will do that before reposting. Thanks for giving it a spin.
Cheers
James
Quoting James Hogan (2013-04-19 09:28:21)
Quoted 5 lines
This patchset adds support for automatic selection of the best parent for a clock mux, i.e. the one which can provide the closest clock rate to that requested. It can be controlled by a new
CLK_SET_RATE_REMUXflag so that it doesn't happen unless explicitly allowed.
I'm not sure about the new flag. One of my regrets during the early development of the common struct clk is the CLK_SET_RATE_PARENT flag. In hindsight I would have preferred to make parent-propagation of rate changes the default behavior, and instead provide a flag to prevent that behavior, such as CLK_SET_RATE_NO_PROPAGATE.
One reason for this is the difficulty some have had with setting flags from DT bindings. Another reason is that a core goal of the framework is to remove topology info from drivers; having to set a flag explicitly on each clock to propagate rate changes is an impediment to that goal.
So perhaps CLK_SET_RATE_REMUX is a similar situation. What do you think about making remuxing the default and providing a flag to prevent it? And also we can assume for the immediate future that users of .determine_rate WANT to remux, since .round_rate won't do it. Though eventually it might be wise to convert all users of .round_rate over to .determine_rate and deprecate .round_rate entirely.
Regards,
Mike
Quoted 48 lines
This works by way of adding a new op,
determine_rate, similar toround_ratebut with an extra parameter to allow the clock driver to optionally select a different parent clock. This is used inclk_calc_new_ratesto decide whether to initiate aset_parentoperation.Changes in v2:
I've moved the mux
determine_rateimplementation into a core helper, but I haven't pushed it fully into the core, as I think it just wouldn't work correctly for more complex clocks, e.g. if you (theoretically) had a combined mux and divide, you'd want to intercept thedetermine_rateand ask for a larger rate from the parent clocks, then return the divided rate. This should be possible by wrapping the muxdetermine_ratehelper.Patch 1 still exports the
__clk_get_parent_by_indexas it seems like it might be a useful thing for clock implementations to have access to if they ever wanted to do something more fancy with changing clock parents.I haven't made any attempt to implement the atomic set_parent+set_rate as I don't have hardware that could take proper advantage of it, but it shouldn't be too difficult for others to implement if they wanted since they're fairly close to one another (in
clk_change_rate()).* switched to using new
determine_rateop rather than adding an argument toround_rate.
* moved mux implementation into a single helper which should be usable from more complex clocks which can mux.
* rewrite main implementation so that no changes are made until after the PRE notifications have been sent, and in a way that should ensure correct notifications without duplicates, and I think should be safe in the event of a notification failing.
* various tidy ups and fixes.James Hogan (3):
clk: abstract parent cache
clk: add support for clock reparent onset_rate
clk: clk-mux: implement remuxing onset_rateDocumentation/clk.txt | 4 + drivers/clk/clk-mux.c | 1 + drivers/clk/clk.c | 216 +++++++++++++++++++++++++++++++++---------- include/linux/clk-private.h | 2 + include/linux/clk-provider.h | 12 +++ 5 files changed, 185 insertions(+), 50 deletions(-)Signature · 1 line
1.8.1.2
Quoted 7 lines · Mike Turquette
Quoting James Hogan (2013-04-19 09:28:21)
Quoted 5 lines
This patchset adds support for automatic selection of the best parent for a clock mux, i.e. the one which can provide the closest clock rate to that requested. It can be controlled by a new
CLK_SET_RATE_REMUXflag so that it doesn't happen unless explicitly allowed.
Quoted 8 lines
I'm not sure about the new flag. One of my regrets during the early development of the common struct clk is the
CLK_SET_RATE_PARENTflag. In hindsight I would have preferred to make parent-propagation of rate changes the default behavior, and instead provide a flag to prevent that behavior, such asCLK_SET_RATE_NO_PROPAGATE.One reason for this is the difficulty some have had with setting flags from DT bindings.
Could you elaborate on this? I've been adding flags to DT bindings for this sort of thing, but it feels a bit like it's in that grey area of not really describing the hardware itself. This information needs to be specified somehow though.
Quoted 3 lines
Another reason is that a core goal of the framework
is to remove topology info from drivers; having to set a flag explicitly on each clock to propagate rate changes is an impediment to that goal.
(Something that I have found also where CLK_SET_RATE_PARENT doesn't fit well is when you have a mux where you want the set_rate propagated to one possible parent (e.g. a dedicated PLL) but not the other (e.g. the system clock - which happens to be a divider). In this case what I really want to say is "don't change the rate of this particular clock", in fact I added a CLK_DIVIDER_READ_ONLY divider flag locally for this purpose. Was there a particular use case of CLK_SET_RATE_PARENT where you'd want a clock to be changed from one child but not another?)
Quoted 3 lines
So perhaps
CLK_SET_RATE_REMUXis a similar situation. What do you think about making remuxing the default and providing a flag to prevent it?
Yes, fine by me.
Quoted 4 lines
And also we can assume for the immediate future that users of .determine_rate WANT to remux, since .round_rate won't do it. Though eventually it might be wise to convert all users of .round_rate over to .determine_rate and deprecate .round_rate entirely.
True.
Cheers
James
v2 cover clk: implement remuxing during set_rate
Quoting James Hogan (2013-05-13 14:30:46)
Quoted 14 lines · Mike Turquette
Quoted 13 lines
Quoting James Hogan (2013-04-19 09:28:21)
Quoted 5 lines
This patchset adds support for automatic selection of the best parent for a clock mux, i.e. the one which can provide the closest clock rate to that requested. It can be controlled by a new
CLK_SET_RATE_REMUXflag so that it doesn't happen unless explicitly allowed.I'm not sure about the new flag. One of my regrets during the early development of the common struct clk is the
CLK_SET_RATE_PARENTflag. In hindsight I would have preferred to make parent-propagation of rate changes the default behavior, and instead provide a flag to prevent that behavior, such asCLK_SET_RATE_NO_PROPAGATE.
Quoted 8 lines
Quoted 2 lines
One reason for this is the difficulty some have had with setting flags from DT bindings.
Could you elaborate on this? I've been adding flags to DT bindings for this sort of thing, but it feels a bit like it's in that grey area of not really describing the hardware itself. This information needs to be specified somehow though.
It depends on the flag. A good example is the CLK_DIVIDER_ONE_BASED flag which does describe the hardware. It informs the binding that indexing starts at 1, not 0, which is a valid part of the hardware description.
However flags that deal with software policy do not belong on DT. CLK_SET_RATE_PARENT certainly does not belong in the DT binding since this is a pure Linux-ism. Every binding just needs to be reviewed on a case-by-case basis to make sure the flags are related only to the hardware.
Regards,
Mike
Quoted 29 lines
Quoted 3 lines
Another reason is that a core goal of the framework
is to remove topology info from drivers; having to set a flag explicitly on each clock to propagate rate changes is an impediment to that goal.(Something that I have found also where
CLK_SET_RATE_PARENTdoesn't fit well is when you have a mux where you want theset_ratepropagated to one possible parent (e.g. a dedicated PLL) but not the other (e.g. the system clock - which happens to be a divider). In this case what I really want to say is "don't change the rate of this particular clock", in fact I added aCLK_DIVIDER_READ_ONLYdivider flag locally for this purpose. Was there a particular use case ofCLK_SET_RATE_PARENTwhere you'd want a clock to be changed from one child but not another?)Quoted 3 lines
So perhaps
CLK_SET_RATE_REMUXis a similar situation. What do you think about making remuxing the default and providing a flag to prevent it?Yes, fine by me.
Quoted 4 lines
And also we can assume for the immediate future that users of .determine_rate WANT to remux, since .round_rate won't do it. Though eventually it might be wise to convert all users of .round_rate over to .determine_rate and deprecate .round_rate entirely.
True.
Cheers
James
Hi Mike,
Quoted 16 lines · Mike Turquette
Quoting James Hogan (2013-05-13 14:30:46)
Quoted 9 lines · Mike Turquette
Quoted 2 lines
One reason for this is the difficulty some have had with setting flags from DT bindings.
Could you elaborate on this? I've been adding flags to DT bindings for this sort of thing, but it feels a bit like it's in that grey area of not really describing the hardware itself. This information needs to be specified somehow though.
It depends on the flag. A good example is the
CLK_DIVIDER_ONE_BASEDflag which does describe the hardware. It informs the binding that indexing starts at 1, not 0, which is a valid part of the hardware description.
Quoted 5 lines
However flags that deal with software policy do not belong on DT.
CLK_SET_RATE_PARENTcertainly does not belong in the DT binding since this is a pure Linux-ism. Every binding just needs to be reviewed on a case-by-case basis to make sure the flags are related only to the hardware.
So given the desire to eliminate platform code, is there a particular way that these other flags can be specified instead of DT bindings?
Cheers
James
v2 cover clk: implement remuxing during set_rate
Quoting James Hogan (2013-05-14 14:01:18)
Quoted 19 lines
Hi Mike,
Quoted 16 lines · Mike Turquette
Quoting James Hogan (2013-05-13 14:30:46)
Quoted 9 lines · Mike Turquette
Quoted 2 lines
One reason for this is the difficulty some have had with setting flags from DT bindings.
Could you elaborate on this? I've been adding flags to DT bindings for this sort of thing, but it feels a bit like it's in that grey area of not really describing the hardware itself. This information needs to be specified somehow though.
It depends on the flag. A good example is the
CLK_DIVIDER_ONE_BASEDflag which does describe the hardware. It informs the binding that indexing starts at 1, not 0, which is a valid part of the hardware description.
Quoted 9 lines
Quoted 5 lines
However flags that deal with software policy do not belong on DT.
CLK_SET_RATE_PARENTcertainly does not belong in the DT binding since this is a pure Linux-ism. Every binding just needs to be reviewed on a case-by-case basis to make sure the flags are related only to the hardware.So given the desire to eliminate platform code, is there a particular way that these other flags can be specified instead of DT bindings?
I haven't put too much thought into this. There have been many discussions lately about where to put configuration data, which would include the "policy" flags. Some folks have discussed using DT, but keeping the config data separate from the hardware description data (one thread I read called the idea "config tree"). Examples of this are setting parents for mux clocks, or setting clock rates at boot-time. This data is important, but it is a configuration of the hardware. Not a description of it.
Anyways it is a general problem, so I'm hoping someone will find a general solution. For now I've seen a couple instance of clock drivers including clk-private.h to modify the flags at registration time, which is beyond horrible. But again those users may not have a better option, short of a new clk_set_flags() function, which is also horrible.
Regards,
Mike
Quoted 2 lines
Cheers
James
Quoted 44 lines · James Hogan
This patchset adds support for automatic selection of the best parent for a clock mux, i.e. the one which can provide the closest clock rate to that requested. It can be controlled by a new
CLK_SET_RATE_REMUXflag so that it doesn't happen unless explicitly allowed.This works by way of adding a new op,
determine_rate, similar toround_ratebut with an extra parameter to allow the clock driver to optionally select a different parent clock. This is used inclk_calc_new_ratesto decide whether to initiate aset_parentoperation.Changes in v2:
I've moved the mux
determine_rateimplementation into a core helper, but I haven't pushed it fully into the core, as I think it just wouldn't work correctly for more complex clocks, e.g. if you (theoretically) had a combined mux and divide, you'd want to intercept thedetermine_rateand ask for a larger rate from the parent clocks, then return the divided rate. This should be possible by wrapping the muxdetermine_ratehelper.Patch 1 still exports the
__clk_get_parent_by_indexas it seems like it might be a useful thing for clock implementations to have access to if they ever wanted to do something more fancy with changing clock parents.I haven't made any attempt to implement the atomic set_parent+set_rate as I don't have hardware that could take proper advantage of it, but it shouldn't be too difficult for others to implement if they wanted since they're fairly close to one another (in
clk_change_rate()).* switched to using new
determine_rateop rather than adding an argument toround_rate.
* moved mux implementation into a single helper which should be usable from more complex clocks which can mux.
* rewrite main implementation so that no changes are made until after the PRE notifications have been sent, and in a way that should ensure correct notifications without duplicates, and I think should be safe in the event of a notification failing.
* various tidy ups and fixes.James Hogan (3):
clk: abstract parent cache
clk: add support for clock reparent onset_rate
clk: clk-mux: implement remuxing onset_rate
Quoted 7 lines
Documentation/clk.txt | 4 + drivers/clk/clk-mux.c | 1 + drivers/clk/clk.c | 216 +++++++++++++++++++++++++++++++++---------- include/linux/clk-private.h | 2 + include/linux/clk-provider.h | 12 +++ 5 files changed, 185 insertions(+), 50 deletions(-)
I really want to review this because I solved the same problem in our internal clock framework and want to make sure upstream doesn't go through the same mistakes. But haven't had the time. Hopefully, I'll go it before this gets accepted by Mike. I'll try to do it this week/weekend.
Thanks,
Saravana
Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, hosted by The Linux Foundation
Quoted 4 lines · Saravana Kannan
I really want to review this because I solved the same problem in our internal clock framework and want to make sure upstream doesn't go through the same mistakes. But haven't had the time. Hopefully, I'll go it before this gets accepted by Mike. I'll try to do it this week/weekend.
Great! FYI I submitted a v3 yesterday, but screwed up and forgot to CC LKML :-(
It can be found on linux-arm-kernel archives here (or if it's a real PITA I can resubmit cc'ing LKML):
http://lists.infradead.org/pipermail/linux-arm-kernel/2013-May/168485.html
Cheers
James