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) */ 138