Commit d0a533b1 authored by Will Deacon's avatar Will Deacon Committed by Russell King
Browse files

ARM: 7452/1: delay: allow timer-based delay implementation to be selected 



This patch allows a timer-based delay implementation to be selected by
switching the delay routines over to use get_cycles, which is
implemented in terms of read_current_timer. This further allows us to
skip the loop calibration and have a consistent delay function in the
face of core frequency scaling.

To avoid the pain of dealing with memory-mapped counters, this
implementation uses the co-processor interface to the architected timers
when they are available. The previous loop-based implementation is
kept around for CPUs without the architected timers and we retain both
the maximum delay (2ms) and the corresponding conversion factors for
determining the number of loops required for a given interval. Since the
indirection of the timer routines will only work when called from C,
the sa1100 sleep routines are modified to branch to the loop-based delay
functions directly.

Tested-by: default avatarShinya Kuribayashi <shinya.kuribayashi.px@renesas.com>
Reviewed-by: default avatarStephen Boyd <sboyd@codeaurora.org>
Signed-off-by: default avatarWill Deacon <will.deacon@arm.com>
Signed-off-by: default avatarRussell King <rmk+kernel@arm.linux.org.uk>
parent 923df96b

arch/arm/include/asm/delay.h

+25 −7
Original line number Diff line number Diff line
@@ -6,9 +6,22 @@ 
#ifndef __ASM_ARM_DELAY_H

#define __ASM_ARM_DELAY_H



#include <asm/memory.h>

#include <asm/param.h>	/* HZ */



extern void __delay(int loops);

#define MAX_UDELAY_MS	2

#define UDELAY_MULT	((UL(2199023) * HZ) >> 11)

#define UDELAY_SHIFT	30



#ifndef __ASSEMBLY__



extern struct arm_delay_ops {

	void (*delay)(unsigned long);

	void (*const_udelay)(unsigned long);

	void (*udelay)(unsigned long);

} arm_delay_ops;



#define __delay(n)		arm_delay_ops.delay(n)



/*

 * This function intentionally does not exist; if you see references to
@@ -23,22 +36,27 @@ extern void __bad_udelay(void); 
 * 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

 * Use only for very small delays ( < 2 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)

 */

extern void __udelay(unsigned long usecs);

extern void __const_udelay(unsigned long);



#define MAX_UDELAY_MS 2

#define __udelay(n)		arm_delay_ops.udelay(n)

#define __const_udelay(n)	arm_delay_ops.const_udelay(n)



#define udelay(n)							\

	(__builtin_constant_p(n) ?					\

	  ((n) > (MAX_UDELAY_MS * 1000) ? __bad_udelay() :		\

			__const_udelay((n) * ((2199023U*HZ)>>11))) :	\

			__const_udelay((n) * UDELAY_MULT)) :		\

	  __udelay(n))



/* Loop-based definitions for assembly code. */

extern void __loop_delay(unsigned long loops);

extern void __loop_udelay(unsigned long usecs);

extern void __loop_const_udelay(unsigned long);



#endif /* __ASSEMBLY__ */



#endif /* defined(_ARM_DELAY_H) */

arch/arm/kernel/arch_timer.c

+3 −0
Original line number Diff line number Diff line
@@ -32,6 +32,8 @@ static int arch_timer_ppi2; 


static struct clock_event_device __percpu **arch_timer_evt;



extern void init_current_timer_delay(unsigned long freq);



/*

 * Architected system timer support.

 */
@@ -304,6 +306,7 @@ static int __init arch_timer_register(void) 
	if (err)

		goto out_free_irq;



	init_current_timer_delay(arch_timer_rate);

	return 0;



out_free_irq:

arch/arm/kernel/armksyms.c

+1 −2
Original line number Diff line number Diff line
@@ -49,8 +49,7 @@ extern void __aeabi_ulcmp(void); 
extern void fpundefinstr(void);



	/* platform dependent support */

EXPORT_SYMBOL(__udelay);

EXPORT_SYMBOL(__const_udelay);

EXPORT_SYMBOL(arm_delay_ops);



	/* networking */

EXPORT_SYMBOL(csum_partial);

arch/arm/lib/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -6,7 +6,7 @@ 


lib-y		:= backtrace.o changebit.o csumipv6.o csumpartial.o   \

		   csumpartialcopy.o csumpartialcopyuser.o clearbit.o \

		   delay.o findbit.o memchr.o memcpy.o		      \

		   delay.o delay-loop.o findbit.o memchr.o memcpy.o   \

		   memmove.o memset.o memzero.o setbit.o              \

		   strncpy_from_user.o strnlen_user.o                 \

		   strchr.o strrchr.o                                 \

arch/arm/lib/delay.S→arch/arm/lib/delay-loop.S

+9 −11
Original line number Diff line number Diff line
@@ -9,11 +9,11 @@ 
 */

#include <linux/linkage.h>

#include <asm/assembler.h>

#include <asm/param.h>

#include <asm/delay.h>

		.text



.LC0:		.word	loops_per_jiffy

.LC1:		.word	(2199023*HZ)>>11

.LC1:		.word	UDELAY_MULT



/*

 * r0  <= 2000
@@ -21,10 +21,10 @@ 
 * HZ  <= 1000

 */



ENTRY(__udelay)

ENTRY(__loop_udelay)

		ldr	r2, .LC1

		mul	r0, r2, r0

ENTRY(__const_udelay)				@ 0 <= r0 <= 0x7fffff06

ENTRY(__loop_const_udelay)			@ 0 <= r0 <= 0x7fffff06

		mov	r1, #-1

		ldr	r2, .LC0

		ldr	r2, [r2]		@ max = 0x01ffffff
@@ -39,12 +39,10 @@ ENTRY(__const_udelay) @ 0 <= r0 <= 0x7fffff06 


/*

 * loops = r0 * HZ * loops_per_jiffy / 1000000

 *

 * Oh, if only we had a cycle counter...

 */



@ Delay routine

ENTRY(__delay)

ENTRY(__loop_delay)

		subs	r0, r0, #1

#if 0

		movls	pc, lr
@@ -62,8 +60,8 @@ ENTRY(__delay) 
		movls	pc, lr

		subs	r0, r0, #1

#endif

		bhi	__delay

		bhi	__loop_delay

		mov	pc, lr

ENDPROC(__udelay)

ENDPROC(__const_udelay)

ENDPROC(__delay)
 
ENDPROC(__loop_udelay)

ENDPROC(__loop_const_udelay)

ENDPROC(__loop_delay)

CRA Git | Maintained and supported by SUSTech CRA and CCSE