Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : #ifndef _LINUX_JIFFIES_H
       3                 :            : #define _LINUX_JIFFIES_H
       4                 :            : 
       5                 :            : #include <linux/cache.h>
       6                 :            : #include <linux/math64.h>
       7                 :            : #include <linux/kernel.h>
       8                 :            : #include <linux/types.h>
       9                 :            : #include <linux/time.h>
      10                 :            : #include <linux/timex.h>
      11                 :            : #include <asm/param.h>                    /* for HZ */
      12                 :            : #include <generated/timeconst.h>
      13                 :            : 
      14                 :            : /*
      15                 :            :  * The following defines establish the engineering parameters of the PLL
      16                 :            :  * model. The HZ variable establishes the timer interrupt frequency, 100 Hz
      17                 :            :  * for the SunOS kernel, 256 Hz for the Ultrix kernel and 1024 Hz for the
      18                 :            :  * OSF/1 kernel. The SHIFT_HZ define expresses the same value as the
      19                 :            :  * nearest power of two in order to avoid hardware multiply operations.
      20                 :            :  */
      21                 :            : #if HZ >= 12 && HZ < 24
      22                 :            : # define SHIFT_HZ       4
      23                 :            : #elif HZ >= 24 && HZ < 48
      24                 :            : # define SHIFT_HZ       5
      25                 :            : #elif HZ >= 48 && HZ < 96
      26                 :            : # define SHIFT_HZ       6
      27                 :            : #elif HZ >= 96 && HZ < 192
      28                 :            : # define SHIFT_HZ       7
      29                 :            : #elif HZ >= 192 && HZ < 384
      30                 :            : # define SHIFT_HZ       8
      31                 :            : #elif HZ >= 384 && HZ < 768
      32                 :            : # define SHIFT_HZ       9
      33                 :            : #elif HZ >= 768 && HZ < 1536
      34                 :            : # define SHIFT_HZ       10
      35                 :            : #elif HZ >= 1536 && HZ < 3072
      36                 :            : # define SHIFT_HZ       11
      37                 :            : #elif HZ >= 3072 && HZ < 6144
      38                 :            : # define SHIFT_HZ       12
      39                 :            : #elif HZ >= 6144 && HZ < 12288
      40                 :            : # define SHIFT_HZ       13
      41                 :            : #else
      42                 :            : # error Invalid value of HZ.
      43                 :            : #endif
      44                 :            : 
      45                 :            : /* Suppose we want to divide two numbers NOM and DEN: NOM/DEN, then we can
      46                 :            :  * improve accuracy by shifting LSH bits, hence calculating:
      47                 :            :  *     (NOM << LSH) / DEN
      48                 :            :  * This however means trouble for large NOM, because (NOM << LSH) may no
      49                 :            :  * longer fit in 32 bits. The following way of calculating this gives us
      50                 :            :  * some slack, under the following conditions:
      51                 :            :  *   - (NOM / DEN) fits in (32 - LSH) bits.
      52                 :            :  *   - (NOM % DEN) fits in (32 - LSH) bits.
      53                 :            :  */
      54                 :            : #define SH_DIV(NOM,DEN,LSH) (   (((NOM) / (DEN)) << (LSH))              \
      55                 :            :                              + ((((NOM) % (DEN)) << (LSH)) + (DEN) / 2) / (DEN))
      56                 :            : 
      57                 :            : /* LATCH is used in the interval timer and ftape setup. */
      58                 :            : #define LATCH ((CLOCK_TICK_RATE + HZ/2) / HZ)   /* For divider */
      59                 :            : 
      60                 :            : extern int register_refined_jiffies(long clock_tick_rate);
      61                 :            : 
      62                 :            : /* TICK_NSEC is the time between ticks in nsec assuming SHIFTED_HZ */
      63                 :            : #define TICK_NSEC ((NSEC_PER_SEC+HZ/2)/HZ)
      64                 :            : 
      65                 :            : /* TICK_USEC is the time between ticks in usec assuming SHIFTED_HZ */
      66                 :            : #define TICK_USEC ((USEC_PER_SEC + HZ/2) / HZ)
      67                 :            : 
      68                 :            : /* USER_TICK_USEC is the time between ticks in usec assuming fake USER_HZ */
      69                 :            : #define USER_TICK_USEC ((1000000UL + USER_HZ/2) / USER_HZ)
      70                 :            : 
      71                 :            : #ifndef __jiffy_arch_data
      72                 :            : #define __jiffy_arch_data
      73                 :            : #endif
      74                 :            : 
      75                 :            : /*
      76                 :            :  * The 64-bit value is not atomic - you MUST NOT read it
      77                 :            :  * without sampling the sequence number in jiffies_lock.
      78                 :            :  * get_jiffies_64() will do this for you as appropriate.
      79                 :            :  */
      80                 :            : extern u64 __cacheline_aligned_in_smp jiffies_64;
      81                 :            : extern unsigned long volatile __cacheline_aligned_in_smp __jiffy_arch_data jiffies;
      82                 :            : 
      83                 :            : #if (BITS_PER_LONG < 64)
      84                 :            : u64 get_jiffies_64(void);
      85                 :            : #else
      86                 :            : static inline u64 get_jiffies_64(void)
      87                 :            : {
      88                 :            :         return (u64)jiffies;
      89                 :            : }
      90                 :            : #endif
      91                 :            : 
      92                 :            : /*
      93                 :            :  *      These inlines deal with timer wrapping correctly. You are 
      94                 :            :  *      strongly encouraged to use them
      95                 :            :  *      1. Because people otherwise forget
      96                 :            :  *      2. Because if the timer wrap changes in future you won't have to
      97                 :            :  *         alter your driver code.
      98                 :            :  *
      99                 :            :  * time_after(a,b) returns true if the time a is after time b.
     100                 :            :  *
     101                 :            :  * Do this with "<0" and ">=0" to only test the sign of the result. A
     102                 :            :  * good compiler would generate better code (and a really good compiler
     103                 :            :  * wouldn't care). Gcc is currently neither.
     104                 :            :  */
     105                 :            : #define time_after(a,b)         \
     106                 :            :         (typecheck(unsigned long, a) && \
     107                 :            :          typecheck(unsigned long, b) && \
     108                 :            :          ((long)((b) - (a)) < 0))
     109                 :            : #define time_before(a,b)        time_after(b,a)
     110                 :            : 
     111                 :            : #define time_after_eq(a,b)      \
     112                 :            :         (typecheck(unsigned long, a) && \
     113                 :            :          typecheck(unsigned long, b) && \
     114                 :            :          ((long)((a) - (b)) >= 0))
     115                 :            : #define time_before_eq(a,b)     time_after_eq(b,a)
     116                 :            : 
     117                 :            : /*
     118                 :            :  * Calculate whether a is in the range of [b, c].
     119                 :            :  */
     120                 :            : #define time_in_range(a,b,c) \
     121                 :            :         (time_after_eq(a,b) && \
     122                 :            :          time_before_eq(a,c))
     123                 :            : 
     124                 :            : /*
     125                 :            :  * Calculate whether a is in the range of [b, c).
     126                 :            :  */
     127                 :            : #define time_in_range_open(a,b,c) \
     128                 :            :         (time_after_eq(a,b) && \
     129                 :            :          time_before(a,c))
     130                 :            : 
     131                 :            : /* Same as above, but does so with platform independent 64bit types.
     132                 :            :  * These must be used when utilizing jiffies_64 (i.e. return value of
     133                 :            :  * get_jiffies_64() */
     134                 :            : #define time_after64(a,b)       \
     135                 :            :         (typecheck(__u64, a) && \
     136                 :            :          typecheck(__u64, b) && \
     137                 :            :          ((__s64)((b) - (a)) < 0))
     138                 :            : #define time_before64(a,b)      time_after64(b,a)
     139                 :            : 
     140                 :            : #define time_after_eq64(a,b)    \
     141                 :            :         (typecheck(__u64, a) && \
     142                 :            :          typecheck(__u64, b) && \
     143                 :            :          ((__s64)((a) - (b)) >= 0))
     144                 :            : #define time_before_eq64(a,b)   time_after_eq64(b,a)
     145                 :            : 
     146                 :            : #define time_in_range64(a, b, c) \
     147                 :            :         (time_after_eq64(a, b) && \
     148                 :            :          time_before_eq64(a, c))
     149                 :            : 
     150                 :            : /*
     151                 :            :  * These four macros compare jiffies and 'a' for convenience.
     152                 :            :  */
     153                 :            : 
     154                 :            : /* time_is_before_jiffies(a) return true if a is before jiffies */
     155                 :            : #define time_is_before_jiffies(a) time_after(jiffies, a)
     156                 :            : #define time_is_before_jiffies64(a) time_after64(get_jiffies_64(), a)
     157                 :            : 
     158                 :            : /* time_is_after_jiffies(a) return true if a is after jiffies */
     159                 :            : #define time_is_after_jiffies(a) time_before(jiffies, a)
     160                 :            : #define time_is_after_jiffies64(a) time_before64(get_jiffies_64(), a)
     161                 :            : 
     162                 :            : /* time_is_before_eq_jiffies(a) return true if a is before or equal to jiffies*/
     163                 :            : #define time_is_before_eq_jiffies(a) time_after_eq(jiffies, a)
     164                 :            : #define time_is_before_eq_jiffies64(a) time_after_eq64(get_jiffies_64(), a)
     165                 :            : 
     166                 :            : /* time_is_after_eq_jiffies(a) return true if a is after or equal to jiffies*/
     167                 :            : #define time_is_after_eq_jiffies(a) time_before_eq(jiffies, a)
     168                 :            : #define time_is_after_eq_jiffies64(a) time_before_eq64(get_jiffies_64(), a)
     169                 :            : 
     170                 :            : /*
     171                 :            :  * Have the 32 bit jiffies value wrap 5 minutes after boot
     172                 :            :  * so jiffies wrap bugs show up earlier.
     173                 :            :  */
     174                 :            : #define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
     175                 :            : 
     176                 :            : /*
     177                 :            :  * Change timeval to jiffies, trying to avoid the
     178                 :            :  * most obvious overflows..
     179                 :            :  *
     180                 :            :  * And some not so obvious.
     181                 :            :  *
     182                 :            :  * Note that we don't want to return LONG_MAX, because
     183                 :            :  * for various timeout reasons we often end up having
     184                 :            :  * to wait "jiffies+1" in order to guarantee that we wait
     185                 :            :  * at _least_ "jiffies" - so "jiffies+1" had better still
     186                 :            :  * be positive.
     187                 :            :  */
     188                 :            : #define MAX_JIFFY_OFFSET ((LONG_MAX >> 1)-1)
     189                 :            : 
     190                 :            : extern unsigned long preset_lpj;
     191                 :            : 
     192                 :            : /*
     193                 :            :  * We want to do realistic conversions of time so we need to use the same
     194                 :            :  * values the update wall clock code uses as the jiffies size.  This value
     195                 :            :  * is: TICK_NSEC (which is defined in timex.h).  This
     196                 :            :  * is a constant and is in nanoseconds.  We will use scaled math
     197                 :            :  * with a set of scales defined here as SEC_JIFFIE_SC,  USEC_JIFFIE_SC and
     198                 :            :  * NSEC_JIFFIE_SC.  Note that these defines contain nothing but
     199                 :            :  * constants and so are computed at compile time.  SHIFT_HZ (computed in
     200                 :            :  * timex.h) adjusts the scaling for different HZ values.
     201                 :            : 
     202                 :            :  * Scaled math???  What is that?
     203                 :            :  *
     204                 :            :  * Scaled math is a way to do integer math on values that would,
     205                 :            :  * otherwise, either overflow, underflow, or cause undesired div
     206                 :            :  * instructions to appear in the execution path.  In short, we "scale"
     207                 :            :  * up the operands so they take more bits (more precision, less
     208                 :            :  * underflow), do the desired operation and then "scale" the result back
     209                 :            :  * by the same amount.  If we do the scaling by shifting we avoid the
     210                 :            :  * costly mpy and the dastardly div instructions.
     211                 :            : 
     212                 :            :  * Suppose, for example, we want to convert from seconds to jiffies
     213                 :            :  * where jiffies is defined in nanoseconds as NSEC_PER_JIFFIE.  The
     214                 :            :  * simple math is: jiff = (sec * NSEC_PER_SEC) / NSEC_PER_JIFFIE; We
     215                 :            :  * observe that (NSEC_PER_SEC / NSEC_PER_JIFFIE) is a constant which we
     216                 :            :  * might calculate at compile time, however, the result will only have
     217                 :            :  * about 3-4 bits of precision (less for smaller values of HZ).
     218                 :            :  *
     219                 :            :  * So, we scale as follows:
     220                 :            :  * jiff = (sec) * (NSEC_PER_SEC / NSEC_PER_JIFFIE);
     221                 :            :  * jiff = ((sec) * ((NSEC_PER_SEC * SCALE)/ NSEC_PER_JIFFIE)) / SCALE;
     222                 :            :  * Then we make SCALE a power of two so:
     223                 :            :  * jiff = ((sec) * ((NSEC_PER_SEC << SCALE)/ NSEC_PER_JIFFIE)) >> SCALE;
     224                 :            :  * Now we define:
     225                 :            :  * #define SEC_CONV = ((NSEC_PER_SEC << SCALE)/ NSEC_PER_JIFFIE))
     226                 :            :  * jiff = (sec * SEC_CONV) >> SCALE;
     227                 :            :  *
     228                 :            :  * Often the math we use will expand beyond 32-bits so we tell C how to
     229                 :            :  * do this and pass the 64-bit result of the mpy through the ">> SCALE"
     230                 :            :  * which should take the result back to 32-bits.  We want this expansion
     231                 :            :  * to capture as much precision as possible.  At the same time we don't
     232                 :            :  * want to overflow so we pick the SCALE to avoid this.  In this file,
     233                 :            :  * that means using a different scale for each range of HZ values (as
     234                 :            :  * defined in timex.h).
     235                 :            :  *
     236                 :            :  * For those who want to know, gcc will give a 64-bit result from a "*"
     237                 :            :  * operator if the result is a long long AND at least one of the
     238                 :            :  * operands is cast to long long (usually just prior to the "*" so as
     239                 :            :  * not to confuse it into thinking it really has a 64-bit operand,
     240                 :            :  * which, buy the way, it can do, but it takes more code and at least 2
     241                 :            :  * mpys).
     242                 :            : 
     243                 :            :  * We also need to be aware that one second in nanoseconds is only a
     244                 :            :  * couple of bits away from overflowing a 32-bit word, so we MUST use
     245                 :            :  * 64-bits to get the full range time in nanoseconds.
     246                 :            : 
     247                 :            :  */
     248                 :            : 
     249                 :            : /*
     250                 :            :  * Here are the scales we will use.  One for seconds, nanoseconds and
     251                 :            :  * microseconds.
     252                 :            :  *
     253                 :            :  * Within the limits of cpp we do a rough cut at the SEC_JIFFIE_SC and
     254                 :            :  * check if the sign bit is set.  If not, we bump the shift count by 1.
     255                 :            :  * (Gets an extra bit of precision where we can use it.)
     256                 :            :  * We know it is set for HZ = 1024 and HZ = 100 not for 1000.
     257                 :            :  * Haven't tested others.
     258                 :            : 
     259                 :            :  * Limits of cpp (for #if expressions) only long (no long long), but
     260                 :            :  * then we only need the most signicant bit.
     261                 :            :  */
     262                 :            : 
     263                 :            : #define SEC_JIFFIE_SC (31 - SHIFT_HZ)
     264                 :            : #if !((((NSEC_PER_SEC << 2) / TICK_NSEC) << (SEC_JIFFIE_SC - 2)) & 0x80000000)
     265                 :            : #undef SEC_JIFFIE_SC
     266                 :            : #define SEC_JIFFIE_SC (32 - SHIFT_HZ)
     267                 :            : #endif
     268                 :            : #define NSEC_JIFFIE_SC (SEC_JIFFIE_SC + 29)
     269                 :            : #define SEC_CONVERSION ((unsigned long)((((u64)NSEC_PER_SEC << SEC_JIFFIE_SC) +\
     270                 :            :                                 TICK_NSEC -1) / (u64)TICK_NSEC))
     271                 :            : 
     272                 :            : #define NSEC_CONVERSION ((unsigned long)((((u64)1 << NSEC_JIFFIE_SC) +\
     273                 :            :                                         TICK_NSEC -1) / (u64)TICK_NSEC))
     274                 :            : /*
     275                 :            :  * The maximum jiffie value is (MAX_INT >> 1).  Here we translate that
     276                 :            :  * into seconds.  The 64-bit case will overflow if we are not careful,
     277                 :            :  * so use the messy SH_DIV macro to do it.  Still all constants.
     278                 :            :  */
     279                 :            : #if BITS_PER_LONG < 64
     280                 :            : # define MAX_SEC_IN_JIFFIES \
     281                 :            :         (long)((u64)((u64)MAX_JIFFY_OFFSET * TICK_NSEC) / NSEC_PER_SEC)
     282                 :            : #else   /* take care of overflow on 64 bits machines */
     283                 :            : # define MAX_SEC_IN_JIFFIES \
     284                 :            :         (SH_DIV((MAX_JIFFY_OFFSET >> SEC_JIFFIE_SC) * TICK_NSEC, NSEC_PER_SEC, 1) - 1)
     285                 :            : 
     286                 :            : #endif
     287                 :            : 
     288                 :            : /*
     289                 :            :  * Convert various time units to each other:
     290                 :            :  */
     291                 :            : extern unsigned int jiffies_to_msecs(const unsigned long j);
     292                 :            : extern unsigned int jiffies_to_usecs(const unsigned long j);
     293                 :            : 
     294                 :            : static inline u64 jiffies_to_nsecs(const unsigned long j)
     295                 :            : {
     296                 :          0 :         return (u64)jiffies_to_usecs(j) * NSEC_PER_USEC;
     297                 :            : }
     298                 :            : 
     299                 :            : extern u64 jiffies64_to_nsecs(u64 j);
     300                 :            : extern u64 jiffies64_to_msecs(u64 j);
     301                 :            : 
     302                 :            : extern unsigned long __msecs_to_jiffies(const unsigned int m);
     303                 :            : #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
     304                 :            : /*
     305                 :            :  * HZ is equal to or smaller than 1000, and 1000 is a nice round
     306                 :            :  * multiple of HZ, divide with the factor between them, but round
     307                 :            :  * upwards:
     308                 :            :  */
     309                 :          3 : static inline unsigned long _msecs_to_jiffies(const unsigned int m)
     310                 :            : {
     311                 :          3 :         return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
     312                 :            : }
     313                 :            : #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
     314                 :            : /*
     315                 :            :  * HZ is larger than 1000, and HZ is a nice round multiple of 1000 -
     316                 :            :  * simply multiply with the factor between them.
     317                 :            :  *
     318                 :            :  * But first make sure the multiplication result cannot overflow:
     319                 :            :  */
     320                 :            : static inline unsigned long _msecs_to_jiffies(const unsigned int m)
     321                 :            : {
     322                 :            :         if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
     323                 :            :                 return MAX_JIFFY_OFFSET;
     324                 :            :         return m * (HZ / MSEC_PER_SEC);
     325                 :            : }
     326                 :            : #else
     327                 :            : /*
     328                 :            :  * Generic case - multiply, round and divide. But first check that if
     329                 :            :  * we are doing a net multiplication, that we wouldn't overflow:
     330                 :            :  */
     331                 :            : static inline unsigned long _msecs_to_jiffies(const unsigned int m)
     332                 :            : {
     333                 :            :         if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
     334                 :            :                 return MAX_JIFFY_OFFSET;
     335                 :            : 
     336                 :            :         return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32) >> MSEC_TO_HZ_SHR32;
     337                 :            : }
     338                 :            : #endif
     339                 :            : /**
     340                 :            :  * msecs_to_jiffies: - convert milliseconds to jiffies
     341                 :            :  * @m:  time in milliseconds
     342                 :            :  *
     343                 :            :  * conversion is done as follows:
     344                 :            :  *
     345                 :            :  * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
     346                 :            :  *
     347                 :            :  * - 'too large' values [that would result in larger than
     348                 :            :  *   MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
     349                 :            :  *
     350                 :            :  * - all other values are converted to jiffies by either multiplying
     351                 :            :  *   the input value by a factor or dividing it with a factor and
     352                 :            :  *   handling any 32-bit overflows.
     353                 :            :  *   for the details see __msecs_to_jiffies()
     354                 :            :  *
     355                 :            :  * msecs_to_jiffies() checks for the passed in value being a constant
     356                 :            :  * via __builtin_constant_p() allowing gcc to eliminate most of the
     357                 :            :  * code, __msecs_to_jiffies() is called if the value passed does not
     358                 :            :  * allow constant folding and the actual conversion must be done at
     359                 :            :  * runtime.
     360                 :            :  * the HZ range specific helpers _msecs_to_jiffies() are called both
     361                 :            :  * directly here and from __msecs_to_jiffies() in the case where
     362                 :            :  * constant folding is not possible.
     363                 :            :  */
     364                 :            : static __always_inline unsigned long msecs_to_jiffies(const unsigned int m)
     365                 :            : {
     366                 :          3 :         if (__builtin_constant_p(m)) {
     367                 :          0 :                 if ((int)m < 0)
     368                 :            :                         return MAX_JIFFY_OFFSET;
     369                 :          3 :                 return _msecs_to_jiffies(m);
     370                 :            :         } else {
     371                 :          3 :                 return __msecs_to_jiffies(m);
     372                 :            :         }
     373                 :            : }
     374                 :            : 
     375                 :            : extern unsigned long __usecs_to_jiffies(const unsigned int u);
     376                 :            : #if !(USEC_PER_SEC % HZ)
     377                 :          0 : static inline unsigned long _usecs_to_jiffies(const unsigned int u)
     378                 :            : {
     379                 :          3 :         return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
     380                 :            : }
     381                 :            : #else
     382                 :            : static inline unsigned long _usecs_to_jiffies(const unsigned int u)
     383                 :            : {
     384                 :            :         return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)
     385                 :            :                 >> USEC_TO_HZ_SHR32;
     386                 :            : }
     387                 :            : #endif
     388                 :            : 
     389                 :            : /**
     390                 :            :  * usecs_to_jiffies: - convert microseconds to jiffies
     391                 :            :  * @u:  time in microseconds
     392                 :            :  *
     393                 :            :  * conversion is done as follows:
     394                 :            :  *
     395                 :            :  * - 'too large' values [that would result in larger than
     396                 :            :  *   MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
     397                 :            :  *
     398                 :            :  * - all other values are converted to jiffies by either multiplying
     399                 :            :  *   the input value by a factor or dividing it with a factor and
     400                 :            :  *   handling any 32-bit overflows as for msecs_to_jiffies.
     401                 :            :  *
     402                 :            :  * usecs_to_jiffies() checks for the passed in value being a constant
     403                 :            :  * via __builtin_constant_p() allowing gcc to eliminate most of the
     404                 :            :  * code, __usecs_to_jiffies() is called if the value passed does not
     405                 :            :  * allow constant folding and the actual conversion must be done at
     406                 :            :  * runtime.
     407                 :            :  * the HZ range specific helpers _usecs_to_jiffies() are called both
     408                 :            :  * directly here and from __msecs_to_jiffies() in the case where
     409                 :            :  * constant folding is not possible.
     410                 :            :  */
     411                 :            : static __always_inline unsigned long usecs_to_jiffies(const unsigned int u)
     412                 :            : {
     413                 :          3 :         if (__builtin_constant_p(u)) {
     414                 :          0 :                 if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
     415                 :            :                         return MAX_JIFFY_OFFSET;
     416                 :          0 :                 return _usecs_to_jiffies(u);
     417                 :            :         } else {
     418                 :          3 :                 return __usecs_to_jiffies(u);
     419                 :            :         }
     420                 :            : }
     421                 :            : 
     422                 :            : extern unsigned long timespec64_to_jiffies(const struct timespec64 *value);
     423                 :            : extern void jiffies_to_timespec64(const unsigned long jiffies,
     424                 :            :                                   struct timespec64 *value);
     425                 :            : static inline unsigned long timespec_to_jiffies(const struct timespec *value)
     426                 :            : {
     427                 :            :         struct timespec64 ts = timespec_to_timespec64(*value);
     428                 :            : 
     429                 :            :         return timespec64_to_jiffies(&ts);
     430                 :            : }
     431                 :            : 
     432                 :            : static inline void jiffies_to_timespec(const unsigned long jiffies,
     433                 :            :                                        struct timespec *value)
     434                 :            : {
     435                 :            :         struct timespec64 ts;
     436                 :            : 
     437                 :            :         jiffies_to_timespec64(jiffies, &ts);
     438                 :            :         *value = timespec64_to_timespec(ts);
     439                 :            : }
     440                 :            : 
     441                 :            : extern unsigned long timeval_to_jiffies(const struct timeval *value);
     442                 :            : extern void jiffies_to_timeval(const unsigned long jiffies,
     443                 :            :                                struct timeval *value);
     444                 :            : 
     445                 :            : extern clock_t jiffies_to_clock_t(unsigned long x);
     446                 :            : static inline clock_t jiffies_delta_to_clock_t(long delta)
     447                 :            : {
     448                 :          0 :         return jiffies_to_clock_t(max(0L, delta));
     449                 :            : }
     450                 :            : 
     451                 :            : static inline unsigned int jiffies_delta_to_msecs(long delta)
     452                 :            : {
     453                 :            :         return jiffies_to_msecs(max(0L, delta));
     454                 :            : }
     455                 :            : 
     456                 :            : extern unsigned long clock_t_to_jiffies(unsigned long x);
     457                 :            : extern u64 jiffies_64_to_clock_t(u64 x);
     458                 :            : extern u64 nsec_to_clock_t(u64 x);
     459                 :            : extern u64 nsecs_to_jiffies64(u64 n);
     460                 :            : extern unsigned long nsecs_to_jiffies(u64 n);
     461                 :            : 
     462                 :            : #define TIMESTAMP_SIZE  30
     463                 :            : 
     464                 :            : #endif