include/linux/delay.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _LINUX_DELAY_H
   3 #define _LINUX_DELAY_H
   4
   5 /*
   6  * Copyright (C) 1993 Linus Torvalds
   7  *
   8  * Delay routines, using a pre-computed "loops_per_jiffy" value.
   9  * Sleep routines using timer list timers or hrtimers.
  10  */
  11
  12 #include <linux/math.h>
  13 #include <linux/sched.h>
  14 #include <linux/jiffies.h>
  15
  16 extern unsigned long loops_per_jiffy;
  17
  18 #include <asm/delay.h>
  19
  20 /*
  21  * Using udelay() for intervals greater than a few milliseconds can
  22  * risk overflow for high loops_per_jiffy (high bogomips) machines. The
  23  * mdelay() provides a wrapper to prevent this.  For delays greater
  24  * than MAX_UDELAY_MS milliseconds, the wrapper is used.  Architecture
  25  * specific values can be defined in asm-???/delay.h as an override.
  26  * The 2nd mdelay() definition ensures GCC will optimize away the
  27  * while loop for the common cases where n <= MAX_UDELAY_MS  --  Paul G.
  28  */
  29 #ifndef MAX_UDELAY_MS
  30 #define MAX_UDELAY_MS   5
  31 #endif
  32
  33 #ifndef mdelay
  34 /**
  35  * mdelay - Inserting a delay based on milliseconds with busy waiting
  36  * @n:  requested delay in milliseconds
  37  *
  38  * See udelay() for basic information about mdelay() and it's variants.
  39  *
  40  * Please double check, whether mdelay() is the right way to go or whether a
  41  * refactoring of the code is the better variant to be able to use msleep()
  42  * instead.
  43  */
  44 #define mdelay(n) (\
  45         (__builtin_constant_p(n) && (n)<=MAX_UDELAY_MS) ? udelay((n)*1000) : \
  46         ({unsigned long __ms=(n); while (__ms--) udelay(1000);}))
  47 #endif
  48
  49 #ifndef ndelay
  50 static inline void ndelay(unsigned long x)
  51 {
  52         udelay(DIV_ROUND_UP(x, 1000));
  53 }
  54 #define ndelay(x) ndelay(x)
  55 #endif
  56
  57 extern unsigned long lpj_fine;
  58 void calibrate_delay(void);
  59 unsigned long calibrate_delay_is_known(void);
  60 void __attribute__((weak)) calibration_delay_done(void);
  61 void msleep(unsigned int msecs);
  62 unsigned long msleep_interruptible(unsigned int msecs);
  63 void usleep_range_state(unsigned long min, unsigned long max,
  64                         unsigned int state);
  65
  66 /**
  67  * usleep_range - Sleep for an approximate time
  68  * @min:        Minimum time in microseconds to sleep
  69  * @max:        Maximum time in microseconds to sleep
  70  *
  71  * For basic information please refere to usleep_range_state().
  72  *
  73  * The task will be in the state TASK_UNINTERRUPTIBLE during the sleep.
  74  */
  75 static inline void usleep_range(unsigned long min, unsigned long max)
  76 {
  77         usleep_range_state(min, max, TASK_UNINTERRUPTIBLE);
  78 }
  79
  80 /**
  81  * usleep_range_idle - Sleep for an approximate time with idle time accounting
  82  * @min:        Minimum time in microseconds to sleep
  83  * @max:        Maximum time in microseconds to sleep
  84  *
  85  * For basic information please refere to usleep_range_state().
  86  *
  87  * The sleeping task has the state TASK_IDLE during the sleep to prevent
  88  * contribution to the load avarage.
  89  */
  90 static inline void usleep_range_idle(unsigned long min, unsigned long max)
  91 {
  92         usleep_range_state(min, max, TASK_IDLE);
  93 }
  94
  95 /**
  96  * ssleep - wrapper for seconds around msleep
  97  * @seconds:    Requested sleep duration in seconds
  98  *
  99  * Please refere to msleep() for detailed information.
 100  */
 101 static inline void ssleep(unsigned int seconds)
 102 {
 103         msleep(seconds * 1000);
 104 }
 105
 106 static const unsigned int max_slack_shift = 2;
 107 #define USLEEP_RANGE_UPPER_BOUND        ((TICK_NSEC << max_slack_shift) / NSEC_PER_USEC)
 108
 109 /**
 110  * fsleep - flexible sleep which autoselects the best mechanism
 111  * @usecs:      requested sleep duration in microseconds
 112  *
 113  * flseep() selects the best mechanism that will provide maximum 25% slack
 114  * to the requested sleep duration. Therefore it uses:
 115  *
 116  * * udelay() loop for sleep durations <= 10 microseconds to avoid hrtimer
 117  *   overhead for really short sleep durations.
 118  * * usleep_range() for sleep durations which would lead with the usage of
 119  *   msleep() to a slack larger than 25%. This depends on the granularity of
 120  *   jiffies.
 121  * * msleep() for all other sleep durations.
 122  *
 123  * Note: When %CONFIG_HIGH_RES_TIMERS is not set, all sleeps are processed with
 124  * the granularity of jiffies and the slack might exceed 25% especially for
 125  * short sleep durations.
 126  */
 127 static inline void fsleep(unsigned long usecs)
 128 {
 129         if (usecs <= 10)
 130                 udelay(usecs);
 131         else if (usecs < USLEEP_RANGE_UPPER_BOUND)
 132                 usleep_range(usecs, usecs + (usecs >> max_slack_shift));
 133         else
 134                 msleep(DIV_ROUND_UP(usecs, USEC_PER_MSEC));
 135 }
 136
 137 #endif /* defined(_LINUX_DELAY_H) */