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

/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 1994 by Waldorf Electronics
 * Copyright (C) 1995 - 2000, 01, 03 by Ralf Baechle
 * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
 * Copyright (C) 2007  Maciej W. Rozycki
 */
#ifndef _ASM_DELAY_H
#define _ASM_DELAY_H

#include <linux/param.h>
#include <linux/smp.h>

#include <asm/compiler.h>
#include <asm/war.h>

static inline void __delay(unsigned long loops)
{
	if (sizeof(long) == 4)
		__asm__ __volatile__ (
		"	.set	noreorder				\n"
		"	.align	3					\n"
		"1:	bnez	%0, 1b					\n"
		"	subu	%0, 1					\n"
		"	.set	reorder					\n"
		: "=r" (loops)
		: "0" (loops));
	else if (sizeof(long) == 8 && !DADDI_WAR)
		__asm__ __volatile__ (
		"	.set	noreorder				\n"
		"	.align	3					\n"
		"1:	bnez	%0, 1b					\n"
		"	dsubu	%0, 1					\n"
		"	.set	reorder					\n"
		: "=r" (loops)
		: "0" (loops));
	else if (sizeof(long) == 8 && DADDI_WAR)
		__asm__ __volatile__ (
		"	.set	noreorder				\n"
		"	.align	3					\n"
		"1:	bnez	%0, 1b					\n"
		"	dsubu	%0, %2					\n"
		"	.set	reorder					\n"
		: "=r" (loops)
		: "0" (loops), "r" (1));
}


/*
 * Division by multiplication: you don't have to worry about
 * loss of precision.
 *
 * Use only for very small delays ( < 1 msec).  Should probably use a
 * lookup table, really, as the multiplications take much too long with
 * short delays.  This is a "reasonable" implementation, though (and the
 * first constant multiplications gets optimized away if the delay is
 * a constant)
 */

static inline void __udelay(unsigned long usecs, unsigned long lpj)
{
	unsigned long hi, lo;

	/*
	 * The rates of 128 is rounded wrongly by the catchall case
	 * for 64-bit.  Excessive precission?  Probably ...
	 */
#if defined(CONFIG_64BIT) && (HZ == 128)
	usecs *= 0x0008637bd05af6c7UL;		/* 2**64 / (1000000 / HZ) */
#elif defined(CONFIG_64BIT)
	usecs *= (0x8000000000000000UL / (500000 / HZ));
#else /* 32-bit junk follows here */
	usecs *= (unsigned long) (((0x8000000000000000ULL / (500000 / HZ)) +
	                           0x80000000ULL) >> 32);
#endif

	if (sizeof(long) == 4)
		__asm__("multu\t%2, %3"
		: "=h" (usecs), "=l" (lo)
		: "r" (usecs), "r" (lpj)
		: GCC_REG_ACCUM);
	else if (sizeof(long) == 8 && !R4000_WAR)
		__asm__("dmultu\t%2, %3"
		: "=h" (usecs), "=l" (lo)
		: "r" (usecs), "r" (lpj)
		: GCC_REG_ACCUM);
	else if (sizeof(long) == 8 && R4000_WAR)
		__asm__("dmultu\t%3, %4\n\tmfhi\t%0"
		: "=r" (usecs), "=h" (hi), "=l" (lo)
		: "r" (usecs), "r" (lpj)
		: GCC_REG_ACCUM);

	__delay(usecs);
}

#define __udelay_val cpu_data[raw_smp_processor_id()].udelay_val

#define udelay(usecs) __udelay((usecs), __udelay_val)

/* make sure "usecs *= ..." in udelay do not overflow. */
#if HZ >= 1000
#define MAX_UDELAY_MS	1
#elif HZ <= 200
#define MAX_UDELAY_MS	5
#else
#define MAX_UDELAY_MS	(1000 / HZ)
#endif

#endif /* _ASM_DELAY_H */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* This file is subject to the terms and conditions of the GNU General Public
	3	* License. See the file "COPYING" in the main directory of this archive
	4	* for more details.
	5	*
	6	* Copyright (C) 1994 by Waldorf Electronics
	7	* Copyright (C) 1995 - 2000, 01, 03 by Ralf Baechle
	8	* Copyright (C) 1999, 2000 Silicon Graphics, Inc.
20d60d99	9	* Copyright (C) 2007 Maciej W. Rozycki
1da177e4 LT	10	*/
	11	#ifndef _ASM_DELAY_H
	12	#define _ASM_DELAY_H
	13
1da177e4	14	#include <linux/param.h>
88de09f3	15	#include <linux/smp.h>
20d60d99	16
1da177e4	17	#include <asm/compiler.h>
20d60d99	18	#include <asm/war.h>
1da177e4	19
1da177e4 LT	20	static inline void __delay(unsigned long loops)
	21	{
	22	if (sizeof(long) == 4)
	23	__asm__ __volatile__ (
5ee82350 RB	24	" .set noreorder \n"
	25	" .align 3 \n"
	26	"1: bnez %0, 1b \n"
	27	" subu %0, 1 \n"
	28	" .set reorder \n"
1da177e4 LT	29	: "=r" (loops)
1da177e4 LT	30	: "0" (loops));
619b6e18	31	else if (sizeof(long) == 8 && !DADDI_WAR)
1da177e4	32	__asm__ __volatile__ (
5ee82350 RB	33	" .set noreorder \n"
	34	" .align 3 \n"
	35	"1: bnez %0, 1b \n"
	36	" dsubu %0, 1 \n"
	37	" .set reorder \n"
	38	: "=r" (loops)
	39	: "0" (loops));
619b6e18 MR	40	else if (sizeof(long) == 8 && DADDI_WAR)
	41	__asm__ __volatile__ (
	42	" .set noreorder \n"
	43	" .align 3 \n"
	44	"1: bnez %0, 1b \n"
	45	" dsubu %0, %2 \n"
	46	" .set reorder \n"
	47	: "=r" (loops)
	48	: "0" (loops), "r" (1));
1da177e4 LT	49	}
	50
	51
	52	/*
	53	* Division by multiplication: you don't have to worry about
	54	* loss of precision.
	55	*
	56	* Use only for very small delays ( < 1 msec). Should probably use a
	57	* lookup table, really, as the multiplications take much too long with
	58	* short delays. This is a "reasonable" implementation, though (and the
	59	* first constant multiplications gets optimized away if the delay is
	60	* a constant)
	61	*/
	62
	63	static inline void __udelay(unsigned long usecs, unsigned long lpj)
	64	{
20d60d99	65	unsigned long hi, lo;
1da177e4 LT	66
1da177e4 LT	67	/*
f12555d2 AN	68	* The rates of 128 is rounded wrongly by the catchall case
f12555d2 AN	69	* for 64-bit. Excessive precission? Probably ...
1da177e4	70	*/
875d43e7	71	#if defined(CONFIG_64BIT) && (HZ == 128)
1da177e4	72	usecs = 0x0008637bd05af6c7UL; / 2*64 / (1000000 / HZ) /
875d43e7	73	#elif defined(CONFIG_64BIT)
1da177e4 LT	74	usecs *= (0x8000000000000000UL / (500000 / HZ));
	75	#else /* 32-bit junk follows here */
	76	usecs *= (unsigned long) (((0x8000000000000000ULL / (500000 / HZ)) +
	77	0x80000000ULL) >> 32);
	78	#endif
	79
	80	if (sizeof(long) == 4)
	81	__asm__("multu\t%2, %3"
	82	: "=h" (usecs), "=l" (lo)
	83	: "r" (usecs), "r" (lpj)
	84	: GCC_REG_ACCUM);
20d60d99	85	else if (sizeof(long) == 8 && !R4000_WAR)
1da177e4 LT	86	__asm__("dmultu\t%2, %3"
	87	: "=h" (usecs), "=l" (lo)
	88	: "r" (usecs), "r" (lpj)
	89	: GCC_REG_ACCUM);
20d60d99 MR	90	else if (sizeof(long) == 8 && R4000_WAR)
	91	__asm__("dmultu\t%3, %4\n\tmfhi\t%0"
	92	: "=r" (usecs), "=h" (hi), "=l" (lo)
	93	: "r" (usecs), "r" (lpj)
	94	: GCC_REG_ACCUM);
1da177e4 LT	95
	96	__delay(usecs);
	97	}
	98
83598f1c	99	#define __udelay_val cpu_data[raw_smp_processor_id()].udelay_val
1da177e4	100
21a151d8	101	#define udelay(usecs) __udelay((usecs), __udelay_val)
1da177e4	102
a0f08209 AN	103	/* make sure "usecs = ..." in udelay do not overflow. /
	104	#if HZ >= 1000
	105	#define MAX_UDELAY_MS 1
	106	#elif HZ <= 200
	107	#define MAX_UDELAY_MS 5
	108	#else
	109	#define MAX_UDELAY_MS (1000 / HZ)
	110	#endif
	111
1da177e4	112	#endif /* _ASM_DELAY_H */