238 lines
6.8 KiB
C
238 lines
6.8 KiB
C
#include <linux/jiffies.h>
|
|
|
|
|
|
|
|
#define HZ_TO_MSEC_MUL32 0xA0000000
|
|
#define HZ_TO_MSEC_ADJ32 0x0
|
|
#define HZ_TO_MSEC_SHR32 28
|
|
#define HZ_TO_MSEC_MUL64 0xA000000000000000
|
|
#define HZ_TO_MSEC_ADJ64 0x0
|
|
#define HZ_TO_MSEC_SHR64 60
|
|
#define MSEC_TO_HZ_MUL32 0xCCCCCCCD
|
|
#define MSEC_TO_HZ_ADJ32 0x733333333
|
|
#define MSEC_TO_HZ_SHR32 35
|
|
#define MSEC_TO_HZ_MUL64 0xCCCCCCCCCCCCCCCD
|
|
#define MSEC_TO_HZ_ADJ64 0x73333333333333333
|
|
#define MSEC_TO_HZ_SHR64 67
|
|
#define HZ_TO_MSEC_NUM 10
|
|
#define HZ_TO_MSEC_DEN 1
|
|
#define MSEC_TO_HZ_NUM 1
|
|
#define MSEC_TO_HZ_DEN 10
|
|
|
|
#define HZ_TO_USEC_MUL32 0x9C400000
|
|
#define HZ_TO_USEC_ADJ32 0x0
|
|
#define HZ_TO_USEC_SHR32 18
|
|
#define HZ_TO_USEC_MUL64 0x9C40000000000000
|
|
#define HZ_TO_USEC_ADJ64 0x0
|
|
#define HZ_TO_USEC_SHR64 50
|
|
#define USEC_TO_HZ_MUL32 0xD1B71759
|
|
#define USEC_TO_HZ_ADJ32 0x1FFF2E48E8A7
|
|
#define USEC_TO_HZ_SHR32 45
|
|
#define USEC_TO_HZ_MUL64 0xD1B71758E219652C
|
|
#define USEC_TO_HZ_ADJ64 0x1FFF2E48E8A71DE69AD4
|
|
#define USEC_TO_HZ_SHR64 77
|
|
#define HZ_TO_USEC_NUM 10000
|
|
#define HZ_TO_USEC_DEN 1
|
|
#define USEC_TO_HZ_NUM 1
|
|
#define USEC_TO_HZ_DEN 10000
|
|
|
|
|
|
#define MSEC_PER_SEC 1000L
|
|
#define USEC_PER_MSEC 1000L
|
|
#define NSEC_PER_USEC 1000L
|
|
#define NSEC_PER_MSEC 1000000L
|
|
#define USEC_PER_SEC 1000000L
|
|
#define NSEC_PER_SEC 1000000000L
|
|
#define FSEC_PER_SEC 1000000000000000LL
|
|
|
|
|
|
unsigned int jiffies_to_msecs(const unsigned long j)
|
|
{
|
|
#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
|
|
return (MSEC_PER_SEC / HZ) * j;
|
|
#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
|
|
return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
|
|
#else
|
|
# if BITS_PER_LONG == 32
|
|
return (HZ_TO_MSEC_MUL32 * j) >> HZ_TO_MSEC_SHR32;
|
|
# else
|
|
return (j * HZ_TO_MSEC_NUM) / HZ_TO_MSEC_DEN;
|
|
# endif
|
|
#endif
|
|
}
|
|
|
|
unsigned int jiffies_to_usecs(const unsigned long j)
|
|
{
|
|
#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
|
|
return (USEC_PER_SEC / HZ) * j;
|
|
#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
|
|
return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC);
|
|
#else
|
|
# if BITS_PER_LONG == 32
|
|
return (HZ_TO_USEC_MUL32 * j) >> HZ_TO_USEC_SHR32;
|
|
# else
|
|
return (j * HZ_TO_USEC_NUM) / HZ_TO_USEC_DEN;
|
|
# endif
|
|
#endif
|
|
}
|
|
|
|
|
|
/*
|
|
* When we convert to jiffies then we interpret incoming values
|
|
* the following way:
|
|
*
|
|
* - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
|
|
*
|
|
* - 'too large' values [that would result in larger than
|
|
* MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
|
|
*
|
|
* - all other values are converted to jiffies by either multiplying
|
|
* the input value by a factor or dividing it with a factor
|
|
*
|
|
* We must also be careful about 32-bit overflows.
|
|
*/
|
|
unsigned long msecs_to_jiffies(const unsigned int m)
|
|
{
|
|
/*
|
|
* Negative value, means infinite timeout:
|
|
*/
|
|
if ((int)m < 0)
|
|
return MAX_JIFFY_OFFSET;
|
|
|
|
#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
|
|
/*
|
|
* HZ is equal to or smaller than 1000, and 1000 is a nice
|
|
* round multiple of HZ, divide with the factor between them,
|
|
* but round upwards:
|
|
*/
|
|
return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
|
|
#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
|
|
/*
|
|
* HZ is larger than 1000, and HZ is a nice round multiple of
|
|
* 1000 - simply multiply with the factor between them.
|
|
*
|
|
* But first make sure the multiplication result cannot
|
|
* overflow:
|
|
*/
|
|
if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
|
|
return MAX_JIFFY_OFFSET;
|
|
|
|
return m * (HZ / MSEC_PER_SEC);
|
|
#else
|
|
/*
|
|
* Generic case - multiply, round and divide. But first
|
|
* check that if we are doing a net multiplication, that
|
|
* we wouldn't overflow:
|
|
*/
|
|
if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
|
|
return MAX_JIFFY_OFFSET;
|
|
|
|
return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32)
|
|
>> MSEC_TO_HZ_SHR32;
|
|
#endif
|
|
}
|
|
EXPORT_SYMBOL(msecs_to_jiffies);
|
|
|
|
unsigned long usecs_to_jiffies(const unsigned int u)
|
|
{
|
|
if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
|
|
return MAX_JIFFY_OFFSET;
|
|
#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
|
|
return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
|
|
#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
|
|
return u * (HZ / USEC_PER_SEC);
|
|
#else
|
|
return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)
|
|
>> USEC_TO_HZ_SHR32;
|
|
#endif
|
|
}
|
|
EXPORT_SYMBOL(usecs_to_jiffies);
|
|
|
|
/*
|
|
* The TICK_NSEC - 1 rounds up the value to the next resolution. Note
|
|
* that a remainder subtract here would not do the right thing as the
|
|
* resolution values don't fall on second boundries. I.e. the line:
|
|
* nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
|
|
* Note that due to the small error in the multiplier here, this
|
|
* rounding is incorrect for sufficiently large values of tv_nsec, but
|
|
* well formed timespecs should have tv_nsec < NSEC_PER_SEC, so we're
|
|
* OK.
|
|
*
|
|
* Rather, we just shift the bits off the right.
|
|
*
|
|
* The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
|
|
* value to a scaled second value.
|
|
*/
|
|
static unsigned long
|
|
__timespec_to_jiffies(unsigned long sec, long nsec)
|
|
{
|
|
nsec = nsec + TICK_NSEC - 1;
|
|
|
|
if (sec >= MAX_SEC_IN_JIFFIES){
|
|
sec = MAX_SEC_IN_JIFFIES;
|
|
nsec = 0;
|
|
}
|
|
return (((u64)sec * SEC_CONVERSION) +
|
|
(((u64)nsec * NSEC_CONVERSION) >>
|
|
(NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
|
|
|
|
}
|
|
|
|
unsigned long
|
|
timespec_to_jiffies(const struct timespec *value)
|
|
{
|
|
return __timespec_to_jiffies(value->tv_sec, value->tv_nsec);
|
|
}
|
|
|
|
EXPORT_SYMBOL(timespec_to_jiffies);
|
|
|
|
void
|
|
jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
|
|
{
|
|
/*
|
|
* Convert jiffies to nanoseconds and separate with
|
|
* one divide.
|
|
*/
|
|
u32 rem;
|
|
value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
|
|
NSEC_PER_SEC, &rem);
|
|
value->tv_nsec = rem;
|
|
}
|
|
EXPORT_SYMBOL(jiffies_to_timespec);
|
|
|
|
s64 div_s64_rem(s64 dividend, s32 divisor, s32 *remainder)
|
|
{
|
|
u64 quotient;
|
|
|
|
if (dividend < 0) {
|
|
quotient = div_u64_rem(-dividend, abs(divisor), (u32 *)remainder);
|
|
*remainder = -*remainder;
|
|
if (divisor > 0)
|
|
quotient = -quotient;
|
|
} else {
|
|
quotient = div_u64_rem(dividend, abs(divisor), (u32 *)remainder);
|
|
if (divisor < 0)
|
|
quotient = -quotient;
|
|
}
|
|
return quotient;
|
|
}
|
|
|
|
struct timespec ns_to_timespec(const s64 nsec)
|
|
{
|
|
struct timespec ts;
|
|
s32 rem;
|
|
|
|
if (!nsec)
|
|
return (struct timespec) {0, 0};
|
|
|
|
ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
|
|
if (unlikely(rem < 0)) {
|
|
ts.tv_sec--;
|
|
rem += NSEC_PER_SEC;
|
|
}
|
|
ts.tv_nsec = rem;
|
|
|
|
return ts;
|
|
}
|
|
|