clocksource: setup mult_orig in clocksource_enable()
PATCH 1/1 clocksource: setup mult_orig in clocksource_enable()
From: Magnus Damm <[email protected]>
Setup clocksource mult_orig in clocksource_enable().
Clocksource drivers can save power by using keeping the device clock disabled while the clocksource is unused.
In practice this means that the enable() and disable() callbacks perform clk_enable() and clk_disable().
The enable() callback may also use clk_get_rate() to get the clock rate from the clock framework. This information can then be used to calculate the shift and mult variables.
Currently the mult_orig variable is setup from mult at registration time only. This is conflicting with the above case since the clock is disabled and the mult variable is not yet calculated at the time of registration.
Moving the mult_orig setup code to clocksource_enable() allows us to both handle the common case with no enable() callback and the mult-changed-after-enable() case.
---
include/linux/clocksource.h | 10 +++++++++- kernel/time/clocksource.c | 3 --- 2 files changed, 9 insertions(+), 4 deletions(-)
include/linux/clocksource.h +9 -1
@@ -288,7 +288,15 @@ static inline cycle_t clocksource_read(s*/ static inline int clocksource_enable (struct clocksource *cs) { -return cs->enable ? cs->enable (cs) :0 ; +int ret =0 ; + +if (cs->enable) + ret = cs->enable (cs); + +/* save mult_orig on enable */ + cs->mult_orig = cs->mult; + +return ret; }/**
kernel/time/clocksource.c +0 -3
@@ -402,9 +402,6 @@ int clocksource_register(struct clocksouunsigned long flags;int ret; -/* save mult_orig on registration */ - c->mult_orig = c->mult; -spin_lock_irqsave (&clocksource_lock, flags); ret =clocksource_enqueue (c);if (!ret)
Commit-ID: a25cbd045a2ffc42787d4dbcbb9c7118f5f42732 Gitweb: http://git.kernel.org/tip/a25cbd045a2ffc42787d4dbcbb9c7118f5f42732 Author: Magnus Damm <[email protected]> AuthorDate: Fri, 1 May 2009 14:45:46 +0900 Committer: Thomas Gleixner <[email protected]> CommitDate: Sat, 2 May 2009 11:45:15 +0200
clocksource: setup mult_orig in clocksource_enable()
Setup clocksource mult_orig in clocksource_enable().
Clocksource drivers can save power by using keeping the device clock disabled while the clocksource is unused.
In practice this means that the enable() and disable() callbacks perform clk_enable() and clk_disable().
The enable() callback may also use clk_get_rate() to get the clock rate from the clock framework. This information can then be used to calculate the shift and mult variables.
Currently the mult_orig variable is setup from mult at registration time only. This is conflicting with the above case since the clock is disabled and the mult variable is not yet calculated at the time of registration.
Moving the mult_orig setup code to clocksource_enable() allows us to both handle the common case with no enable() callback and the mult-changed-after-enable() case.
[ Impact: allow dynamic clock source usage ]
LKML-Reference: <[email protected]>
--- include/linux/clocksource.h | 10 +++++++++- kernel/time/clocksource.c | 3 --- 2 files changed, 9 insertions(+), 4 deletions(-)
include/linux/clocksource.h +9 -1
@@ -288,7 +288,15 @@ static inline cycle_t clocksource_read(struct clocksource *cs)*/ static inline int clocksource_enable (struct clocksource *cs) { -return cs->enable ? cs->enable (cs) :0 ; +int ret =0 ; + +if (cs->enable) + ret = cs->enable (cs); + +/* save mult_orig on enable */ + cs->mult_orig = cs->mult; + +return ret; }/**
kernel/time/clocksource.c +0 -3
@@ -402,9 +402,6 @@ int clocksource_register(struct clocksource *c)unsigned long flags;int ret; -/* save mult_orig on registration */ - c->mult_orig = c->mult; -spin_lock_irqsave (&clocksource_lock, flags); ret =clocksource_enqueue (c);if (!ret)
Quoted 3 lines · Magnus Damm
From: Magnus Damm <[email protected]>
Setup clocksource
mult_originclocksource_enable().
Hey Magnus,
Sorry I missed this earlier, I just noticed it in the -tip tree.
I've some concerns below.
Quoted 9 lines
Clocksource drivers can save power by using keeping the device clock disabled while the clocksource is unused.
In practice this means that the
enable()anddisable()callbacks performclk_enable()andclk_disable().The
enable()callback may also useclk_get_rate()to get the clock rate from the clock framework. This information can then be used to calculate the shift and mult variables.
Hrmmm.. So when the clocksource code was designed, it was expected that the clocksource mult value would be set prior to registration, and then would not be modified by any user other then the timekeeping core. As changing the mult value directly (on a clocksource thats being used) could cause time inconsistencies.
Quoted 4 lines
Currently the
mult_origvariable is setup from mult at registration time only. This is conflicting with the above case since the clock is disabled and the mult variable is not yet calculated at the time of registration.
Is there really no way to calculate the mult value prior to registration? Maybe quickly enabling, getting the freq, and then disabling?
Quoted 18 lines
Moving the
mult_origsetup code toclocksource_enable()allows us to both handle the common case with noenable()callback and the mult-changed-after-enable() case.Signed-off-by Magnus Damm <[email protected]>---
include/linux/clocksource.h | 10 +++++++++- kernel/time/clocksource.c | 3 --- 2 files changed, 9 insertions(+), 4 deletions(-)include/linux/clocksource.h +0
-1@@ -288,7 +288,15 @@ static inline cycle_t clocksource_read(s*/ static inline int clocksource_enable (struct clocksource *cs) { -return cs->enable ? cs->enable (cs) :0 ;
include/linux/clocksource.h static inline cycle_t clocksource_read(s · line 300
Quoted 10 lines
include/linux/clocksource.h +9
-0+int ret =0 ; + +if (cs->enable) + ret = cs->enable (cs); + +/* save mult_orig on enable */ + cs->mult_orig = cs->mult; + +return ret; }
So this seems like it will break if a clocksource is switched away from and then back to (the reason we added mult_orig in the first place). Since the re-enabled clocksource would then save off its modified mult value into mult_orig.
thanks
-john
Hi John,
Quoted 7 lines · john stultz
Quoted 3 lines · Magnus Damm
From: Magnus Damm <[email protected]>
Setup clocksource
mult_originclocksource_enable().Hey Magnus,
Sorry I missed this earlier, I just noticed it in the -tip tree.
No worries!
Quoted 12 lines
I've some concerns below.
Quoted 9 lines
Clocksource drivers can save power by using keeping the device clock disabled while the clocksource is unused.
In practice this means that the
enable()anddisable()callbacks performclk_enable()andclk_disable().The
enable()callback may also useclk_get_rate()to get the clock rate from the clock framework. This information can then be used to calculate the shift and mult variables.
Quoted 5 lines
Hrmmm.. So when the clocksource code was designed, it was expected that the clocksource mult value would be set prior to registration, and then would not be modified by any user other then the timekeeping core. As changing the mult value directly (on a clocksource thats being used) could cause time inconsistencies.
But no one is changing the mult value on a clocksource that is being used in this case, no? I may remember wrong, but isn't clocksource_enable() called on unused clocksources that soon will become used?
Quoted 8 lines
Quoted 4 lines
Currently the
mult_origvariable is setup from mult at registration time only. This is conflicting with the above case since the clock is disabled and the mult variable is not yet calculated at the time of registration.Is there really no way to calculate the mult value prior to registration? Maybe quickly enabling, getting the freq, and then disabling?
I can't think of any way that would work. The clock frequency can be changed while the clock is disabled. And we can only know the rate after enabling the clock, see these lines from include/linux/clk.h:
/**
* clk_get_rate - obtain the current clock rate (in Hz) for a clock source.
* This is only valid once the clock source has been enabled.
* @clk: clock source
*/
unsigned long clk_get_rate(struct clk *clk);
Quoted 14 lines
Quoted 14 lines
include/linux/clocksource.h 2009-05-01 12:59:27.000000000 +0900 renamed from include/linux/clocksource.h +7
-1@@ -288,7 +288,15 @@ static inline cycle_t clocksource_read(s */ static inline int clocksource_enable(struct clocksource *cs) { - return cs->enable ? cs->enable(cs) : 0; + int ret = 0; + + if (cs->enable) + ret = cs->enable(cs); + + /* save mult_orig on enable */ + cs->mult_orig = cs->mult;
Quoted 8 lines
include/linux/clocksource.h 2009-05-01 12:59:27.000000000 +0900 static inline cycle_t clocksource_read(s · line 300
Quoted 3 lines
include/linux/clocksource.h 2009-05-01 12:59:27.000000000 +0900 renamed from include/linux/clocksource.h +2
-0+ + return ret; }So this seems like it will break if a clocksource is switched away from and then back to (the reason we added
mult_origin the first place). Since the re-enabled clocksource would then save off its modified mult value intomult_orig.
Oh, I see. Sorry about that. I wonder if adding a "cs->mult = cs->orig_mult;" to clock_disable() would help?
/ magnus
Quoted 31 lines · Magnus Damm
Hi John,
Quoted 7 lines · john stultz
Quoted 3 lines · Magnus Damm
From: Magnus Damm <[email protected]>
Setup clocksource
mult_originclocksource_enable().Hey Magnus,
Sorry I missed this earlier, I just noticed it in the -tip tree.No worries!
Quoted 12 lines
I've some concerns below.
Quoted 9 lines
Clocksource drivers can save power by using keeping the device clock disabled while the clocksource is unused.
In practice this means that the
enable()anddisable()callbacks performclk_enable()andclk_disable().The
enable()callback may also useclk_get_rate()to get the clock rate from the clock framework. This information can then be used to calculate the shift and mult variables.Quoted 5 lines
Hrmmm.. So when the clocksource code was designed, it was expected that the clocksource mult value would be set prior to registration, and then would not be modified by any user other then the timekeeping core. As changing the mult value directly (on a clocksource thats being used) could cause time inconsistencies.
Quoted 4 lines
But no one is changing the mult value on a clocksource that is being used in this case, no? I may remember wrong, but isn't
clocksource_enable()called on unused clocksources that soon will become used?
True, but having mult change after registration is still somewhat unexpected behavior (to me at least).
Quoted 13 lines
Quoted 8 lines
Quoted 4 lines
Currently the
mult_origvariable is setup from mult at registration time only. This is conflicting with the above case since the clock is disabled and the mult variable is not yet calculated at the time of registration.Is there really no way to calculate the mult value prior to registration? Maybe quickly enabling, getting the freq, and then disabling?
I can't think of any way that would work. The clock frequency can be changed while the clock is disabled. And we can only know the rate after enabling the clock, see these lines from
include/linux/clk.h:
Quoted 6 lines
/**
*clk_get_rate- obtain the current clock rate (in Hz) for a clock source.
* This is only valid once the clock source has been enabled.
* @clk: clock source
*/
unsigned longclk_get_rate(struct clk *clk);
Hrmm.. Yuck.
Is this really expected behavior that a clk would change frequencies between uses as a clocksource?
Do you have some examples where this code is actually used?
Quoted 23 lines
Quoted 14 lines
Quoted 14 lines
include/linux/clocksource.h 2009-05-01 12:59:27.000000000 +0900 renamed from include/linux/clocksource.h +7
-1@@ -288,7 +288,15 @@ static inline cycle_t clocksource_read(s */ static inline int clocksource_enable(struct clocksource *cs) { - return cs->enable ? cs->enable(cs) : 0; + int ret = 0; + + if (cs->enable) + ret = cs->enable(cs); + + /* save mult_orig on enable */ + cs->mult_orig = cs->mult;Quoted 8 lines
include/linux/clocksource.h 2009-05-01 12:59:27.000000000 +0900 static inline cycle_t clocksource_read(s · line 300
Quoted 3 lines
include/linux/clocksource.h 2009-05-01 12:59:27.000000000 +0900 renamed from include/linux/clocksource.h +2
-0+ + return ret; }So this seems like it will break if a clocksource is switched away from and then back to (the reason we added
mult_origin the first place). Since the re-enabled clocksource would then save off its modified mult value intomult_orig.
Quoted 2 lines
Oh, I see. Sorry about that. I wonder if adding a "
cs->mult=cs->orig_mult;" toclock_disable()would help?
Technically it would. Although we lose the corrective factor that had already been applied, but that should readjust fairly quickly.
So yea, at a minimum setting mult back to orig_mult would be needed for this patch to work.
However, its just ugly. I don't really like the idea of clocksources freq changes under us (even if they're not actively in use). But I may have to just deal with the reality. :(
thanks
-john
Quoted 17 lines · john stultz
Quoted 9 lines · Magnus Damm
Quoted 3 lines · john stultz
Is there really no way to calculate the mult value prior to registration? Maybe quickly enabling, getting the freq, and then disabling?
I can't think of any way that would work. The clock frequency can be changed while the clock is disabled. And we can only know the rate after enabling the clock, see these lines from
include/linux/clk.h:Quoted 6 lines
/**
*clk_get_rate- obtain the current clock rate (in Hz) for a clock source.
* This is only valid once the clock source has been enabled.
* @clk: clock source
*/
unsigned longclk_get_rate(struct clk *clk);
Quoted 4 lines
Hrmm.. Yuck.
Is this really expected behavior that a clk would change frequencies between uses as a clocksource?
Yes, I think so. The clock frequency can change through cpufreq or clk_set_rate().
Quoted 1 line
Do you have some examples where this code is actually used?
Everywhere. =) Many embedded platforms use the clock framework for (runtime power) management of clocks, and clk_get_rate() is the standard way of getting the frequency of a certain clock. Just grep in drivers/, or check out the timer code currently used by SuperH in driver/clocksource/ or drivers/clocksource/tcb_clksrc.c.
Quoted 5 lines
Quoted 5 lines
Quoted 4 lines
So this seems like it will break if a clocksource is switched away from and then back to (the reason we added
mult_origin the first place). Since the re-enabled clocksource would then save off its modified mult value intomult_orig.
Quoted 8 lines
Quoted 2 lines
Oh, I see. Sorry about that. I wonder if adding a "
cs->mult=cs->orig_mult;" toclock_disable()would help?Technically it would. Although we lose the corrective factor that had already been applied, but that should readjust fairly quickly.
So yea, at a minimum setting mult back to
orig_multwould be needed for this patch to work.
Want me to write a patch for it, or do you prefer to handle it yourself?
Quoted 3 lines
However, its just ugly. I don't really like the idea of clocksources freq changes under us (even if they're not actively in use). But I may have to just deal with the reality. :(
Yeah, I agree that the mult/org_mult save/restore code is far from pretty. Unfortunately I think we all have to live with that unused clocks can get their frequencies changed. It's just the way the clock framework is designed. I'm open to any suggestions how to deal with it in a cleaner way...
Another option would be that we don't register multiple clocksources - only one at a time - but I then we would have to invent some layer on top of clocksources. I prefer registering a bunch of clocksources and letting the generic clocksource code use the rating to decide which one to enable. I think that's pretty close to how x86 does things, no?
Any ideas?
Cheers,
/ magnus
Quoted 18 lines · Magnus Damm
Quoted 17 lines · john stultz
Quoted 15 lines · Magnus Damm
Quoted 3 lines · john stultz
Is there really no way to calculate the mult value prior to registration? Maybe quickly enabling, getting the freq, and then disabling?
I can't think of any way that would work. The clock frequency can be changed while the clock is disabled. And we can only know the rate after enabling the clock, see these lines from
include/linux/clk.h:/**
*clk_get_rate- obtain the current clock rate (in Hz) for a clock source.
* This is only valid once the clock source has been enabled.
* @clk: clock source
*/
unsigned longclk_get_rate(struct clk *clk);
Quoted 7 lines
Quoted 4 lines
Hrmm.. Yuck.
Is this really expected behavior that a clk would change frequencies between uses as a clocksource?
Yes, I think so. The clock frequency can change through cpufreq or
clk_set_rate().
But they do not change freq (through cpufreq or anything else) after the enable() call, right? That would be pretty critical. Otherwise they'd need to be disqualified like we do the TSC on x86.
Quoted 7 lines
Quoted 1 line
Do you have some examples where this code is actually used?
Everywhere. =) Many embedded platforms use the clock framework for (runtime power) management of clocks, and
clk_get_rate()is the standard way of getting the frequency of a certain clock. Just grep indrivers/, or check out the timer code currently used by SuperH in driver/clocksource/ ordrivers/clocksource/tcb_clksrc.c.
Yea, I was just curious which clocksources were actually using the clk framework. Thanks for the pointer, I'll take a look.
Quoted 8 lines
Quoted 8 lines
Quoted 7 lines
Quoted 4 lines
So this seems like it will break if a clocksource is switched away from and then back to (the reason we added
mult_origin the first place). Since the re-enabled clocksource would then save off its modified mult value intomult_orig.Oh, I see. Sorry about that. I wonder if adding a "
cs->mult=cs->orig_mult;" toclock_disable()would help?
Quoted 7 lines
Quoted 5 lines
Technically it would. Although we lose the corrective factor that had already been applied, but that should readjust fairly quickly.
So yea, at a minimum setting mult back to
orig_multwould be needed for this patch to work.Want me to write a patch for it, or do you prefer to handle it yourself?
You should submit it. Its just a tweak on your prior patch.
Quoted 10 lines
Quoted 3 lines
However, its just ugly. I don't really like the idea of clocksources freq changes under us (even if they're not actively in use). But I may have to just deal with the reality. :(
Yeah, I agree that the mult/org_mult save/restore code is far from pretty. Unfortunately I think we all have to live with that unused clocks can get their frequencies changed. It's just the way the clock framework is designed. I'm open to any suggestions how to deal with it in a cleaner way...
Quoted 5 lines
Another option would be that we don't register multiple clocksources - only one at a time - but I then we would have to invent some layer on top of clocksources. I prefer registering a bunch of clocksources and letting the generic clocksource code use the rating to decide which one to enable. I think that's pretty close to how x86 does things, no?
Right. We don't want to duplicate the clocksource selection code.
So we'll just live with it. If you could please throw a big comment around the orig_mult/mult assignments explaining why its necessary to do it there.
thanks
-john
Quoted 19 lines · john stultz
Quoted 18 lines · Magnus Damm
Quoted 16 lines · john stultz
Quoted 10 lines · Magnus Damm
I can't think of any way that would work. The clock frequency can be changed while the clock is disabled. And we can only know the rate after enabling the clock, see these lines from
include/linux/clk.h:/**
*clk_get_rate- obtain the current clock rate (in Hz) for a clock source.
* This is only valid once the clock source has been enabled.
* @clk: clock source
*/
unsigned longclk_get_rate(struct clk *clk);Hrmm.. Yuck.
Is this really expected behavior that a clk would change frequencies between uses as a clocksource?
Quoted 7 lines
Quoted 2 lines
Yes, I think so. The clock frequency can change through cpufreq or
clk_set_rate().But they do not change freq (through cpufreq or anything else) after the
enable()call, right? That would be pretty critical. Otherwise they'd need to be disqualified like we do the TSC on x86.
This is a bit tricky, the clock needs to be able to adjust its parent divisors/multipliers in order to maintain its current frequency if a parent clock changes frequency. We do not presently prohibit a frequency change that deviates from the current frequency on these clocks, but this would be trivially handled by setting a fixed rate flag for those clocks. This sort of logic is necessary to block frequency changes in the parent clock topology that would throw the child clock's frequency out of sync. Note that in the general case we do not want to disable frequency changes on enabled clocks, enabled clocks only need to know whether they can handle a frequency change or not without destabilizing the system.
The only thing the usecount presently disables on an enabled clock is reparenting it. ie, migrating between different parent PLLs while in active use.
There is no fundamental limitation as with the TSC, we can have as much or as little flexibility as we like.
Quoted 27 lines · Paul Mundt
Quoted 19 lines · john stultz
Quoted 18 lines · Magnus Damm
Quoted 16 lines · john stultz
Quoted 10 lines · Magnus Damm
I can't think of any way that would work. The clock frequency can be changed while the clock is disabled. And we can only know the rate after enabling the clock, see these lines from
include/linux/clk.h:/**
*clk_get_rate- obtain the current clock rate (in Hz) for a clock source.
* This is only valid once the clock source has been enabled.
* @clk: clock source
*/
unsigned longclk_get_rate(struct clk *clk);Hrmm.. Yuck.
Is this really expected behavior that a clk would change frequencies between uses as a clocksource?
Quoted 7 lines
Quoted 2 lines
Yes, I think so. The clock frequency can change through cpufreq or
clk_set_rate().But they do not change freq (through cpufreq or anything else) after the
enable()call, right? That would be pretty critical. Otherwise they'd need to be disqualified like we do the TSC on x86.
Quoted 10 lines
This is a bit tricky, the clock needs to be able to adjust its parent divisors/multipliers in order to maintain its current frequency if a parent clock changes frequency. We do not presently prohibit a frequency change that deviates from the current frequency on these clocks, but this would be trivially handled by setting a fixed rate flag for those clocks. This sort of logic is necessary to block frequency changes in the parent clock topology that would throw the child clock's frequency out of sync. Note that in the general case we do not want to disable frequency changes on enabled clocks, enabled clocks only need to know whether they can handle a frequency change or not without destabilizing the system.
Any change to the freq mult value in the clocksource would be destabilizing. So I'd advise pretty strongly to make sure that clk's being used as clocksources cannot change frequency once they're enabled and in use.
thanks
-john
Quoted 8 lines · john stultz
Quoted 5 lines · Magnus Damm
Quoted 2 lines · john stultz
So yea, at a minimum setting mult back to
orig_multwould be needed for this patch to work.Want me to write a patch for it, or do you prefer to handle it yourself?
You should submit it. Its just a tweak on your prior patch.
So Linus already merged your patch that breaks mult_orig, so fixing this is a bit more of a priority. Let me know if you have the cycles to fix it and if not I'll take a swing at it.
thanks
-john