Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 87d8b9eb authored by Stephen Boyd's avatar Stephen Boyd Committed by John Stultz
Browse files

clocksource: Extract max nsec calculation into separate function 



We need to calculate the same number in the clocksource code and
the sched_clock code, so extract this code into its own function.
We also drop the min_t and just use min() because the two types
are the same.

Signed-off-by: default avatarStephen Boyd <sboyd@codeaurora.org>
Signed-off-by: default avatarJohn Stultz <john.stultz@linaro.org>
parent ad81f054

include/linux/clocksource.h

+2 −0
Original line number Original line Diff line number Diff line
@@ -292,6 +292,8 @@ extern void clocksource_resume(void); 
extern struct clocksource * __init __weak clocksource_default_clock(void);

extern struct clocksource * __init __weak clocksource_default_clock(void);

extern void clocksource_mark_unstable(struct clocksource *cs);

extern void clocksource_mark_unstable(struct clocksource *cs);





extern u64

clocks_calc_max_nsecs(u32 mult, u32 shift, u32 maxadj, u64 mask);

extern void

extern void

clocks_calc_mult_shift(u32 *mult, u32 *shift, u32 from, u32 to, u32 minsec);

clocks_calc_mult_shift(u32 *mult, u32 *shift, u32 from, u32 to, u32 minsec);

kernel/time/clocksource.c

+30 −15
Original line number Original line Diff line number Diff line
@@ -537,40 +537,55 @@ static u32 clocksource_max_adjustment(struct clocksource *cs) 
}

}





/**

/**

 * clocksource_max_deferment - Returns max time the clocksource can be deferred

 * clocks_calc_max_nsecs - Returns maximum nanoseconds that can be converted

 * @cs:         Pointer to clocksource

 * @mult:	cycle to nanosecond multiplier

 *

 * @shift:	cycle to nanosecond divisor (power of two)

 * @maxadj:	maximum adjustment value to mult (~11%)

 * @mask:	bitmask for two's complement subtraction of non 64 bit counters

 */

 */

static u64 clocksource_max_deferment(struct clocksource *cs)

u64 clocks_calc_max_nsecs(u32 mult, u32 shift, u32 maxadj, u64 mask)

{

{

	u64 max_nsecs, max_cycles;

	u64 max_nsecs, max_cycles;





	/*

	/*

	 * Calculate the maximum number of cycles that we can pass to the

	 * Calculate the maximum number of cycles that we can pass to the

	 * cyc2ns function without overflowing a 64-bit signed result. The

	 * cyc2ns function without overflowing a 64-bit signed result. The

	 * maximum number of cycles is equal to ULLONG_MAX/(cs->mult+cs->maxadj)

	 * maximum number of cycles is equal to ULLONG_MAX/(mult+maxadj)

	 * which is equivalent to the below.

	 * which is equivalent to the below.

	 * max_cycles < (2^63)/(cs->mult + cs->maxadj)

	 * max_cycles < (2^63)/(mult + maxadj)

	 * max_cycles < 2^(log2((2^63)/(cs->mult + cs->maxadj)))

	 * max_cycles < 2^(log2((2^63)/(mult + maxadj)))

	 * max_cycles < 2^(log2(2^63) - log2(cs->mult + cs->maxadj))

	 * max_cycles < 2^(log2(2^63) - log2(mult + maxadj))

	 * max_cycles < 2^(63 - log2(cs->mult + cs->maxadj))

	 * max_cycles < 2^(63 - log2(mult + maxadj))

	 * max_cycles < 1 << (63 - log2(cs->mult + cs->maxadj))

	 * max_cycles < 1 << (63 - log2(mult + maxadj))

	 * Please note that we add 1 to the result of the log2 to account for

	 * Please note that we add 1 to the result of the log2 to account for

	 * any rounding errors, ensure the above inequality is satisfied and

	 * any rounding errors, ensure the above inequality is satisfied and

	 * no overflow will occur.

	 * no overflow will occur.

	 */

	 */

	max_cycles = 1ULL << (63 - (ilog2(cs->mult + cs->maxadj) + 1));

	max_cycles = 1ULL << (63 - (ilog2(mult + maxadj) + 1));





	/*

	/*

	 * The actual maximum number of cycles we can defer the clocksource is

	 * The actual maximum number of cycles we can defer the clocksource is

	 * determined by the minimum of max_cycles and cs->mask.

	 * determined by the minimum of max_cycles and mask.

	 * Note: Here we subtract the maxadj to make sure we don't sleep for

	 * Note: Here we subtract the maxadj to make sure we don't sleep for

	 * too long if there's a large negative adjustment.

	 * too long if there's a large negative adjustment.

	 */

	 */

	max_cycles = min_t(u64, max_cycles, (u64) cs->mask);

	max_cycles = min(max_cycles, mask);

	max_nsecs = clocksource_cyc2ns(max_cycles, cs->mult - cs->maxadj,

	max_nsecs = clocksource_cyc2ns(max_cycles, mult - maxadj, shift);

					cs->shift);



	return max_nsecs;

}



/**

 * clocksource_max_deferment - Returns max time the clocksource can be deferred

 * @cs:         Pointer to clocksource

 *

 */

static u64 clocksource_max_deferment(struct clocksource *cs)

{

	u64 max_nsecs;





	max_nsecs = clocks_calc_max_nsecs(cs->mult, cs->shift, cs->maxadj,

					  cs->mask);

	/*

	/*

	 * To ensure that the clocksource does not wrap whilst we are idle,

	 * To ensure that the clocksource does not wrap whilst we are idle,

	 * limit the time the clocksource can be deferred by 12.5%. Please

	 * limit the time the clocksource can be deferred by 12.5%. Please