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
ndelay(unsigned long x)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 */
usleep_range(unsigned long min,unsigned long max)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 */
usleep_range_idle(unsigned long min,unsigned long max)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 */
ssleep(unsigned int seconds)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 */
fsleep(unsigned long usecs)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) */
138