[linux-2.6-block.git] / include / linux / delay.h

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _LINUX_DELAY_H
#define _LINUX_DELAY_H

/*
 * Copyright (C) 1993 Linus Torvalds
 *
 * Delay routines, using a pre-computed "loops_per_jiffy" value.
 *
 * Please note that ndelay(), udelay() and mdelay() may return early for
 * several reasons:
 *  1. computed loops_per_jiffy too low (due to the time taken to
 *     execute the timer interrupt.)
 *  2. cache behaviour affecting the time it takes to execute the
 *     loop function.
 *  3. CPU clock rate changes.
 *
 * Please see this thread:
 *   https://lists.openwall.net/linux-kernel/2011/01/09/56
 */

#include <linux/math.h>
#include <linux/sched.h>

extern unsigned long loops_per_jiffy;

#include <asm/delay.h>

/*
 * Using udelay() for intervals greater than a few milliseconds can
 * risk overflow for high loops_per_jiffy (high bogomips) machines. The
 * mdelay() provides a wrapper to prevent this.  For delays greater
 * than MAX_UDELAY_MS milliseconds, the wrapper is used.  Architecture
 * specific values can be defined in asm-???/delay.h as an override.
 * The 2nd mdelay() definition ensures GCC will optimize away the 
 * while loop for the common cases where n <= MAX_UDELAY_MS  --  Paul G.
 */

#ifndef MAX_UDELAY_MS
#define MAX_UDELAY_MS	5
#endif

#ifndef mdelay
#define mdelay(n) (\
	(__builtin_constant_p(n) && (n)<=MAX_UDELAY_MS) ? udelay((n)*1000) : \
	({unsigned long __ms=(n); while (__ms--) udelay(1000);}))
#endif

#ifndef ndelay
static inline void ndelay(unsigned long x)
{
	udelay(DIV_ROUND_UP(x, 1000));
}
#define ndelay(x) ndelay(x)
#endif

extern unsigned long lpj_fine;
void calibrate_delay(void);
void __attribute__((weak)) calibration_delay_done(void);
void msleep(unsigned int msecs);
unsigned long msleep_interruptible(unsigned int msecs);
void usleep_range_state(unsigned long min, unsigned long max,
			unsigned int state);

static inline void usleep_range(unsigned long min, unsigned long max)
{
	usleep_range_state(min, max, TASK_UNINTERRUPTIBLE);
}

static inline void usleep_idle_range(unsigned long min, unsigned long max)
{
	usleep_range_state(min, max, TASK_IDLE);
}

static inline void ssleep(unsigned int seconds)
{
	msleep(seconds * 1000);
}

/* see Documentation/timers/timers-howto.rst for the thresholds */
static inline void fsleep(unsigned long usecs)
{
	if (usecs <= 10)
		udelay(usecs);
	else if (usecs <= 20000)
		usleep_range(usecs, 2 * usecs);
	else
		msleep(DIV_ROUND_UP(usecs, 1000));
}

#endif /* defined(_LINUX_DELAY_H) */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
1da177e4 LT	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.
9f819798 RK	9	*
	10	* Please note that ndelay(), udelay() and mdelay() may return early for
	11	* several reasons:
	12	* 1. computed loops_per_jiffy too low (due to the time taken to
	13	* execute the timer interrupt.)
	14	* 2. cache behaviour affecting the time it takes to execute the
	15	* loop function.
	16	* 3. CPU clock rate changes.
	17	*
	18	* Please see this thread:
7f317d34	19	* https://lists.openwall.net/linux-kernel/2011/01/09/56
1da177e4 LT	20	*/
1da177e4 LT	21
5f6286a6	22	#include <linux/math.h>
e4779015	23	#include <linux/sched.h>
5cba6d22	24
1da177e4 LT	25	extern unsigned long loops_per_jiffy;
	26
	27	#include <asm/delay.h>
	28
	29	/*
	30	* Using udelay() for intervals greater than a few milliseconds can
	31	* risk overflow for high loops_per_jiffy (high bogomips) machines. The
	32	* mdelay() provides a wrapper to prevent this. For delays greater
	33	* than MAX_UDELAY_MS milliseconds, the wrapper is used. Architecture
	34	* specific values can be defined in asm-???/delay.h as an override.
	35	* The 2nd mdelay() definition ensures GCC will optimize away the
	36	* while loop for the common cases where n <= MAX_UDELAY_MS -- Paul G.
	37	*/
	38
	39	#ifndef MAX_UDELAY_MS
	40	#define MAX_UDELAY_MS 5
	41	#endif
	42
1e92a550	43	#ifndef mdelay
1da177e4 LT	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
5cba6d22 AM	50	static inline void ndelay(unsigned long x)
	51	{
	52	udelay(DIV_ROUND_UP(x, 1000));
	53	}
	54	#define ndelay(x) ndelay(x)
1da177e4 LT	55	#endif
1da177e4 LT	56
f3f3149f	57	extern unsigned long lpj_fine;
1da177e4	58	void calibrate_delay(void);
8496ecd0	59	void __attribute__((weak)) calibration_delay_done(void);
1da177e4 LT	60	void msleep(unsigned int msecs);
1da177e4 LT	61	unsigned long msleep_interruptible(unsigned int msecs);
e4779015 SP	62	void usleep_range_state(unsigned long min, unsigned long max,
	63	unsigned int state);
	64
	65	static inline void usleep_range(unsigned long min, unsigned long max)
	66	{
	67	usleep_range_state(min, max, TASK_UNINTERRUPTIBLE);
	68	}
	69
	70	static inline void usleep_idle_range(unsigned long min, unsigned long max)
	71	{
	72	usleep_range_state(min, max, TASK_IDLE);
	73	}
1da177e4 LT	74
	75	static inline void ssleep(unsigned int seconds)
	76	{
	77	msleep(seconds * 1000);
	78	}
	79
c6af13d3 HK	80	/* see Documentation/timers/timers-howto.rst for the thresholds */
	81	static inline void fsleep(unsigned long usecs)
	82	{
	83	if (usecs <= 10)
	84	udelay(usecs);
	85	else if (usecs <= 20000)
	86	usleep_range(usecs, 2 * usecs);
	87	else
	88	msleep(DIV_ROUND_UP(usecs, 1000));
	89	}
	90
1da177e4	91	#endif /* defined(_LINUX_DELAY_H) */