Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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
16extern 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
50static inline void ndelay(unsigned long x)
51{
52 udelay(DIV_ROUND_UP(x, 1000));
53}
54#define ndelay(x) ndelay(x)
55#endif
56
57extern unsigned long lpj_fine;
58void calibrate_delay(void);
59unsigned long calibrate_delay_is_known(void);
60void __attribute__((weak)) calibration_delay_done(void);
61void msleep(unsigned int msecs);
62unsigned long msleep_interruptible(unsigned int msecs);
63void 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 */
75static 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 */
90static 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 */
101static inline void ssleep(unsigned int seconds)
102{
103 msleep(seconds * 1000);
104}
105
106static 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 */
127static 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) */