[linux-2.6-block.git] / arch / arm / kernel / entry-common.S

/*
 *  linux/arch/arm/kernel/entry-common.S
 *
 *  Copyright (C) 2000 Russell King
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <asm/unistd.h>
#include <asm/ftrace.h>
#include <mach/entry-macro.S>
#include <asm/unwind.h>

#include "entry-header.S"


	.align	5
/*
 * This is the fast syscall return path.  We do as little as
 * possible here, and this includes saving r0 back into the SVC
 * stack.
 */
ret_fast_syscall:
 UNWIND(.fnstart	)
 UNWIND(.cantunwind	)
	disable_irq				@ disable interrupts
	ldr	r1, [tsk, #TI_FLAGS]
	tst	r1, #_TIF_WORK_MASK
	bne	fast_work_pending

	/* perform architecture specific actions before user return */
	arch_ret_to_user r1, lr

	restore_user_regs fast = 1, offset = S_OFF
 UNWIND(.fnend		)

/*
 * Ok, we need to do extra processing, enter the slow path.
 */
fast_work_pending:
	str	r0, [sp, #S_R0+S_OFF]!		@ returned r0
work_pending:
	tst	r1, #_TIF_NEED_RESCHED
	bne	work_resched
	tst	r1, #_TIF_SIGPENDING|_TIF_NOTIFY_RESUME
	beq	no_work_pending
	mov	r0, sp				@ 'regs'
	mov	r2, why				@ 'syscall'
	bl	do_notify_resume
	b	ret_slow_syscall		@ Check work again

work_resched:
	bl	schedule
/*
 * "slow" syscall return path.  "why" tells us if this was a real syscall.
 */
ENTRY(ret_to_user)
ret_slow_syscall:
	disable_irq				@ disable interrupts
	ldr	r1, [tsk, #TI_FLAGS]
	tst	r1, #_TIF_WORK_MASK
	bne	work_pending
no_work_pending:
	/* perform architecture specific actions before user return */
	arch_ret_to_user r1, lr

	restore_user_regs fast = 0, offset = 0
ENDPROC(ret_to_user)

/*
 * This is how we return from a fork.
 */
ENTRY(ret_from_fork)
	bl	schedule_tail
	get_thread_info tsk
	ldr	r1, [tsk, #TI_FLAGS]		@ check for syscall tracing
	mov	why, #1
	tst	r1, #_TIF_SYSCALL_TRACE		@ are we tracing syscalls?
	beq	ret_slow_syscall
	mov	r1, sp
	mov	r0, #1				@ trace exit [IP = 1]
	bl	syscall_trace
	b	ret_slow_syscall
ENDPROC(ret_from_fork)

	.equ NR_syscalls,0
#define CALL(x) .equ NR_syscalls,NR_syscalls+1
#include "calls.S"
#undef CALL
#define CALL(x) .long x

#ifdef CONFIG_FUNCTION_TRACER
/*
 * When compiling with -pg, gcc inserts a call to the mcount routine at the
 * start of every function.  In mcount, apart from the function's address (in
 * lr), we need to get hold of the function's caller's address.
 *
 * Older GCCs (pre-4.4) inserted a call to a routine called mcount like this:
 *
 *	bl	mcount
 *
 * These versions have the limitation that in order for the mcount routine to
 * be able to determine the function's caller's address, an APCS-style frame
 * pointer (which is set up with something like the code below) is required.
 *
 *	mov     ip, sp
 *	push    {fp, ip, lr, pc}
 *	sub     fp, ip, #4
 *
 * With EABI, these frame pointers are not available unless -mapcs-frame is
 * specified, and if building as Thumb-2, not even then.
 *
 * Newer GCCs (4.4+) solve this problem by introducing a new version of mcount,
 * with call sites like:
 *
 *	push	{lr}
 *	bl	__gnu_mcount_nc
 *
 * With these compilers, frame pointers are not necessary.
 *
 * mcount can be thought of as a function called in the middle of a subroutine
 * call.  As such, it needs to be transparent for both the caller and the
 * callee: the original lr needs to be restored when leaving mcount, and no
 * registers should be clobbered.  (In the __gnu_mcount_nc implementation, we
 * clobber the ip register.  This is OK because the ARM calling convention
 * allows it to be clobbered in subroutines and doesn't use it to hold
 * parameters.)
 */
#ifdef CONFIG_DYNAMIC_FTRACE
ENTRY(mcount)
	stmdb	sp!, {r0-r3, lr}
	mov	r0, lr
	sub	r0, r0, #MCOUNT_INSN_SIZE

	.globl mcount_call
mcount_call:
	bl	ftrace_stub
	ldr	lr, [fp, #-4]			@ restore lr
	ldmia	sp!, {r0-r3, pc}

ENTRY(ftrace_caller)
	stmdb	sp!, {r0-r3, lr}
	ldr	r1, [fp, #-4]
	mov	r0, lr
	sub	r0, r0, #MCOUNT_INSN_SIZE

	.globl ftrace_call
ftrace_call:
	bl	ftrace_stub
	ldr	lr, [fp, #-4]			@ restore lr
	ldmia	sp!, {r0-r3, pc}

#else

ENTRY(__gnu_mcount_nc)
	stmdb	sp!, {r0-r3, lr}
	ldr	r0, =ftrace_trace_function
	ldr	r2, [r0]
	adr	r0, ftrace_stub
	cmp	r0, r2
	bne	gnu_trace
	ldmia	sp!, {r0-r3, ip, lr}
	mov	pc, ip

gnu_trace:
	ldr	r1, [sp, #20]			@ lr of instrumented routine
	mov	r0, lr
	sub	r0, r0, #MCOUNT_INSN_SIZE
	mov	lr, pc
	mov	pc, r2
	ldmia	sp!, {r0-r3, ip, lr}
	mov	pc, ip

ENTRY(mcount)
	stmdb	sp!, {r0-r3, lr}
	ldr	r0, =ftrace_trace_function
	ldr	r2, [r0]
	adr	r0, ftrace_stub
	cmp	r0, r2
	bne	trace
	ldr	lr, [fp, #-4]			@ restore lr
	ldmia	sp!, {r0-r3, pc}

trace:
	ldr	r1, [fp, #-4]			@ lr of instrumented routine
	mov	r0, lr
	sub	r0, r0, #MCOUNT_INSN_SIZE
	mov	lr, pc
	mov	pc, r2
	ldr	lr, [fp, #-4]			@ restore lr
	ldmia	sp!, {r0-r3, pc}

#endif /* CONFIG_DYNAMIC_FTRACE */

	.globl ftrace_stub
ftrace_stub:
	mov	pc, lr

#endif /* CONFIG_FUNCTION_TRACER */

/*=============================================================================
 * SWI handler
 *-----------------------------------------------------------------------------
 */

	/* If we're optimising for StrongARM the resulting code won't 
	   run on an ARM7 and we can save a couple of instructions.  
								--pb */
#ifdef CONFIG_CPU_ARM710
#define A710(code...) code
.Larm710bug:
	ldmia	sp, {r0 - lr}^			@ Get calling r0 - lr
	mov	r0, r0
	add	sp, sp, #S_FRAME_SIZE
	subs	pc, lr, #4
#else
#define A710(code...)
#endif

	.align	5
ENTRY(vector_swi)
	sub	sp, sp, #S_FRAME_SIZE
	stmia	sp, {r0 - r12}			@ Calling r0 - r12
 ARM(	add	r8, sp, #S_PC		)
 ARM(	stmdb	r8, {sp, lr}^		)	@ Calling sp, lr
 THUMB(	mov	r8, sp			)
 THUMB(	store_user_sp_lr r8, r10, S_SP	)	@ calling sp, lr
	mrs	r8, spsr			@ called from non-FIQ mode, so ok.
	str	lr, [sp, #S_PC]			@ Save calling PC
	str	r8, [sp, #S_PSR]		@ Save CPSR
	str	r0, [sp, #S_OLD_R0]		@ Save OLD_R0
	zero_fp

	/*
	 * Get the system call number.
	 */

#if defined(CONFIG_OABI_COMPAT)

	/*
	 * If we have CONFIG_OABI_COMPAT then we need to look at the swi
	 * value to determine if it is an EABI or an old ABI call.
	 */
#ifdef CONFIG_ARM_THUMB
	tst	r8, #PSR_T_BIT
	movne	r10, #0				@ no thumb OABI emulation
	ldreq	r10, [lr, #-4]			@ get SWI instruction
#else
	ldr	r10, [lr, #-4]			@ get SWI instruction
  A710(	and	ip, r10, #0x0f000000		@ check for SWI		)
  A710(	teq	ip, #0x0f000000						)
  A710(	bne	.Larm710bug						)
#endif
#ifdef CONFIG_CPU_ENDIAN_BE8
	rev	r10, r10			@ little endian instruction
#endif

#elif defined(CONFIG_AEABI)

	/*
	 * Pure EABI user space always put syscall number into scno (r7).
	 */
  A710(	ldr	ip, [lr, #-4]			@ get SWI instruction	)
  A710(	and	ip, ip, #0x0f000000		@ check for SWI		)
  A710(	teq	ip, #0x0f000000						)
  A710(	bne	.Larm710bug						)

#elif defined(CONFIG_ARM_THUMB)

	/* Legacy ABI only, possibly thumb mode. */
	tst	r8, #PSR_T_BIT			@ this is SPSR from save_user_regs
	addne	scno, r7, #__NR_SYSCALL_BASE	@ put OS number in
	ldreq	scno, [lr, #-4]

#else

	/* Legacy ABI only. */
	ldr	scno, [lr, #-4]			@ get SWI instruction
  A710(	and	ip, scno, #0x0f000000		@ check for SWI		)
  A710(	teq	ip, #0x0f000000						)
  A710(	bne	.Larm710bug						)

#endif

#ifdef CONFIG_ALIGNMENT_TRAP
	ldr	ip, __cr_alignment
	ldr	ip, [ip]
	mcr	p15, 0, ip, c1, c0		@ update control register
#endif
	enable_irq

	get_thread_info tsk
	adr	tbl, sys_call_table		@ load syscall table pointer
	ldr	ip, [tsk, #TI_FLAGS]		@ check for syscall tracing

#if defined(CONFIG_OABI_COMPAT)
	/*
	 * If the swi argument is zero, this is an EABI call and we do nothing.
	 *
	 * If this is an old ABI call, get the syscall number into scno and
	 * get the old ABI syscall table address.
	 */
	bics	r10, r10, #0xff000000
	eorne	scno, r10, #__NR_OABI_SYSCALL_BASE
	ldrne	tbl, =sys_oabi_call_table
#elif !defined(CONFIG_AEABI)
	bic	scno, scno, #0xff000000		@ mask off SWI op-code
	eor	scno, scno, #__NR_SYSCALL_BASE	@ check OS number
#endif

	stmdb	sp!, {r4, r5}			@ push fifth and sixth args
	tst	ip, #_TIF_SYSCALL_TRACE		@ are we tracing syscalls?
	bne	__sys_trace

	cmp	scno, #NR_syscalls		@ check upper syscall limit
	adr	lr, BSYM(ret_fast_syscall)	@ return address
	ldrcc	pc, [tbl, scno, lsl #2]		@ call sys_* routine

	add	r1, sp, #S_OFF
2:	mov	why, #0				@ no longer a real syscall
	cmp	scno, #(__ARM_NR_BASE - __NR_SYSCALL_BASE)
	eor	r0, scno, #__NR_SYSCALL_BASE	@ put OS number back
	bcs	arm_syscall	
	b	sys_ni_syscall			@ not private func
ENDPROC(vector_swi)

	/*
	 * This is the really slow path.  We're going to be doing
	 * context switches, and waiting for our parent to respond.
	 */
__sys_trace:
	mov	r2, scno
	add	r1, sp, #S_OFF
	mov	r0, #0				@ trace entry [IP = 0]
	bl	syscall_trace

	adr	lr, BSYM(__sys_trace_return)	@ return address
	mov	scno, r0			@ syscall number (possibly new)
	add	r1, sp, #S_R0 + S_OFF		@ pointer to regs
	cmp	scno, #NR_syscalls		@ check upper syscall limit
	ldmccia	r1, {r0 - r3}			@ have to reload r0 - r3
	ldrcc	pc, [tbl, scno, lsl #2]		@ call sys_* routine
	b	2b

__sys_trace_return:
	str	r0, [sp, #S_R0 + S_OFF]!	@ save returned r0
	mov	r2, scno
	mov	r1, sp
	mov	r0, #1				@ trace exit [IP = 1]
	bl	syscall_trace
	b	ret_slow_syscall

	.align	5
#ifdef CONFIG_ALIGNMENT_TRAP
	.type	__cr_alignment, #object
__cr_alignment:
	.word	cr_alignment
#endif
	.ltorg

/*
 * This is the syscall table declaration for native ABI syscalls.
 * With EABI a couple syscalls are obsolete and defined as sys_ni_syscall.
 */
#define ABI(native, compat) native
#ifdef CONFIG_AEABI
#define OBSOLETE(syscall) sys_ni_syscall
#else
#define OBSOLETE(syscall) syscall
#endif

	.type	sys_call_table, #object
ENTRY(sys_call_table)
#include "calls.S"
#undef ABI
#undef OBSOLETE

/*============================================================================
 * Special system call wrappers
 */
@ r0 = syscall number
@ r8 = syscall table
sys_syscall:
		bic	scno, r0, #__NR_OABI_SYSCALL_BASE
		cmp	scno, #__NR_syscall - __NR_SYSCALL_BASE
		cmpne	scno, #NR_syscalls	@ check range
		stmloia	sp, {r5, r6}		@ shuffle args
		movlo	r0, r1
		movlo	r1, r2
		movlo	r2, r3
		movlo	r3, r4
		ldrlo	pc, [tbl, scno, lsl #2]
		b	sys_ni_syscall
ENDPROC(sys_syscall)

sys_fork_wrapper:
		add	r0, sp, #S_OFF
		b	sys_fork
ENDPROC(sys_fork_wrapper)

sys_vfork_wrapper:
		add	r0, sp, #S_OFF
		b	sys_vfork
ENDPROC(sys_vfork_wrapper)

sys_execve_wrapper:
		add	r3, sp, #S_OFF
		b	sys_execve
ENDPROC(sys_execve_wrapper)

sys_clone_wrapper:
		add	ip, sp, #S_OFF
		str	ip, [sp, #4]
		b	sys_clone
ENDPROC(sys_clone_wrapper)

sys_sigreturn_wrapper:
		add	r0, sp, #S_OFF
		b	sys_sigreturn
ENDPROC(sys_sigreturn_wrapper)

sys_rt_sigreturn_wrapper:
		add	r0, sp, #S_OFF
		b	sys_rt_sigreturn
ENDPROC(sys_rt_sigreturn_wrapper)

sys_sigaltstack_wrapper:
		ldr	r2, [sp, #S_OFF + S_SP]
		b	do_sigaltstack
ENDPROC(sys_sigaltstack_wrapper)

sys_statfs64_wrapper:
		teq	r1, #88
		moveq	r1, #84
		b	sys_statfs64
ENDPROC(sys_statfs64_wrapper)

sys_fstatfs64_wrapper:
		teq	r1, #88
		moveq	r1, #84
		b	sys_fstatfs64
ENDPROC(sys_fstatfs64_wrapper)

/*
 * Note: off_4k (r5) is always units of 4K.  If we can't do the requested
 * offset, we return EINVAL.
 */
sys_mmap2:
#if PAGE_SHIFT > 12
		tst	r5, #PGOFF_MASK
		moveq	r5, r5, lsr #PAGE_SHIFT - 12
		streq	r5, [sp, #4]
		beq	sys_mmap_pgoff
		mov	r0, #-EINVAL
		mov	pc, lr
#else
		str	r5, [sp, #4]
		b	sys_mmap_pgoff
#endif
ENDPROC(sys_mmap2)

#ifdef CONFIG_OABI_COMPAT

/*
 * These are syscalls with argument register differences
 */

sys_oabi_pread64:
		stmia	sp, {r3, r4}
		b	sys_pread64
ENDPROC(sys_oabi_pread64)

sys_oabi_pwrite64:
		stmia	sp, {r3, r4}
		b	sys_pwrite64
ENDPROC(sys_oabi_pwrite64)

sys_oabi_truncate64:
		mov	r3, r2
		mov	r2, r1
		b	sys_truncate64
ENDPROC(sys_oabi_truncate64)

sys_oabi_ftruncate64:
		mov	r3, r2
		mov	r2, r1
		b	sys_ftruncate64
ENDPROC(sys_oabi_ftruncate64)

sys_oabi_readahead:
		str	r3, [sp]
		mov	r3, r2
		mov	r2, r1
		b	sys_readahead
ENDPROC(sys_oabi_readahead)

/*
 * Let's declare a second syscall table for old ABI binaries
 * using the compatibility syscall entries.
 */
#define ABI(native, compat) compat
#define OBSOLETE(syscall) syscall

	.type	sys_oabi_call_table, #object
ENTRY(sys_oabi_call_table)
#include "calls.S"
#undef ABI
#undef OBSOLETE

#endif
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/arm/kernel/entry-common.S
	3	*
	4	* Copyright (C) 2000 Russell King
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*/
1da177e4	10
1da177e4	11	#include <asm/unistd.h>
395a59d0	12	#include <asm/ftrace.h>
a09e64fb	13	#include <mach/entry-macro.S>
c4c5716e	14	#include <asm/unwind.h>
1da177e4 LT	15
	16	#include "entry-header.S"
	17
1da177e4 LT	18
	19	.align 5
	20	/*
	21	* This is the fast syscall return path. We do as little as
	22	* possible here, and this includes saving r0 back into the SVC
	23	* stack.
	24	*/
	25	ret_fast_syscall:
c4c5716e CM	26	UNWIND(.fnstart )
c4c5716e CM	27	UNWIND(.cantunwind )
1ec42c0c	28	disable_irq @ disable interrupts
1da177e4 LT	29	ldr r1, [tsk, #TI_FLAGS]
	30	tst r1, #_TIF_WORK_MASK
	31	bne fast_work_pending
f4dc9a4c	32
f80dff9d DW	33	/* perform architecture specific actions before user return */
	34	arch_ret_to_user r1, lr
	35
b86040a5	36	restore_user_regs fast = 1, offset = S_OFF
c4c5716e	37	UNWIND(.fnend )
1da177e4 LT	38
	39	/*
	40	* Ok, we need to do extra processing, enter the slow path.
	41	*/
	42	fast_work_pending:
	43	str r0, [sp, #S_R0+S_OFF]! @ returned r0
	44	work_pending:
	45	tst r1, #_TIF_NEED_RESCHED
	46	bne work_resched
d0420c83	47	tst r1, #_TIF_SIGPENDING\|_TIF_NOTIFY_RESUME
1da177e4 LT	48	beq no_work_pending
	49	mov r0, sp @ 'regs'
	50	mov r2, why @ 'syscall'
	51	bl do_notify_resume
a6c61e9d	52	b ret_slow_syscall @ Check work again
1da177e4 LT	53
	54	work_resched:
	55	bl schedule
	56	/*
	57	* "slow" syscall return path. "why" tells us if this was a real syscall.
	58	*/
	59	ENTRY(ret_to_user)
	60	ret_slow_syscall:
1ec42c0c	61	disable_irq @ disable interrupts
1da177e4 LT	62	ldr r1, [tsk, #TI_FLAGS]
	63	tst r1, #_TIF_WORK_MASK
	64	bne work_pending
	65	no_work_pending:
f80dff9d DW	66	/* perform architecture specific actions before user return */
	67	arch_ret_to_user r1, lr
	68
b86040a5	69	restore_user_regs fast = 0, offset = 0
93ed3970	70	ENDPROC(ret_to_user)
1da177e4 LT	71
	72	/*
	73	* This is how we return from a fork.
	74	*/
	75	ENTRY(ret_from_fork)
	76	bl schedule_tail
	77	get_thread_info tsk
	78	ldr r1, [tsk, #TI_FLAGS] @ check for syscall tracing
	79	mov why, #1
	80	tst r1, #_TIF_SYSCALL_TRACE @ are we tracing syscalls?
	81	beq ret_slow_syscall
	82	mov r1, sp
	83	mov r0, #1 @ trace exit [IP = 1]
	84	bl syscall_trace
	85	b ret_slow_syscall
93ed3970	86	ENDPROC(ret_from_fork)
1da177e4	87
fa1b4f91 AV	88	.equ NR_syscalls,0
fa1b4f91 AV	89	#define CALL(x) .equ NR_syscalls,NR_syscalls+1
1da177e4	90	#include "calls.S"
fa1b4f91 AV	91	#undef CALL
fa1b4f91 AV	92	#define CALL(x) .long x
1da177e4	93
606576ce	94	#ifdef CONFIG_FUNCTION_TRACER
686ff228 RV	95	/*
	96	* When compiling with -pg, gcc inserts a call to the mcount routine at the
	97	* start of every function. In mcount, apart from the function's address (in
	98	* lr), we need to get hold of the function's caller's address.
	99	*
	100	* Older GCCs (pre-4.4) inserted a call to a routine called mcount like this:
	101	*
	102	* bl mcount
	103	*
	104	* These versions have the limitation that in order for the mcount routine to
	105	* be able to determine the function's caller's address, an APCS-style frame
	106	* pointer (which is set up with something like the code below) is required.
	107	*
	108	* mov ip, sp
	109	* push {fp, ip, lr, pc}
	110	* sub fp, ip, #4
	111	*
	112	* With EABI, these frame pointers are not available unless -mapcs-frame is
	113	* specified, and if building as Thumb-2, not even then.
	114	*
	115	* Newer GCCs (4.4+) solve this problem by introducing a new version of mcount,
	116	* with call sites like:
	117	*
	118	* push {lr}
	119	* bl __gnu_mcount_nc
	120	*
	121	* With these compilers, frame pointers are not necessary.
	122	*
	123	* mcount can be thought of as a function called in the middle of a subroutine
	124	* call. As such, it needs to be transparent for both the caller and the
	125	* callee: the original lr needs to be restored when leaving mcount, and no
	126	* registers should be clobbered. (In the __gnu_mcount_nc implementation, we
	127	* clobber the ip register. This is OK because the ARM calling convention
	128	* allows it to be clobbered in subroutines and doesn't use it to hold
	129	* parameters.)
	130	*/
014c257c AS	131	#ifdef CONFIG_DYNAMIC_FTRACE
014c257c AS	132	ENTRY(mcount)
28e192d6 RV	133	stmdb sp!, {r0-r3, lr}
	134	mov r0, lr
	135	sub r0, r0, #MCOUNT_INSN_SIZE
014c257c AS	136
	137	.globl mcount_call
	138	mcount_call:
28e192d6 RV	139	bl ftrace_stub
	140	ldr lr, [fp, #-4] @ restore lr
	141	ldmia sp!, {r0-r3, pc}
014c257c AS	142
014c257c AS	143	ENTRY(ftrace_caller)
28e192d6 RV	144	stmdb sp!, {r0-r3, lr}
	145	ldr r1, [fp, #-4]
	146	mov r0, lr
	147	sub r0, r0, #MCOUNT_INSN_SIZE
014c257c AS	148
	149	.globl ftrace_call
	150	ftrace_call:
28e192d6 RV	151	bl ftrace_stub
	152	ldr lr, [fp, #-4] @ restore lr
	153	ldmia sp!, {r0-r3, pc}
014c257c AS	154
	155	#else
	156
181f817e	157	ENTRY(__gnu_mcount_nc)
28e192d6 RV	158	stmdb sp!, {r0-r3, lr}
	159	ldr r0, =ftrace_trace_function
	160	ldr r2, [r0]
	161	adr r0, ftrace_stub
	162	cmp r0, r2
	163	bne gnu_trace
	164	ldmia sp!, {r0-r3, ip, lr}
	165	mov pc, ip
181f817e UKK	166
181f817e UKK	167	gnu_trace:
28e192d6 RV	168	ldr r1, [sp, #20] @ lr of instrumented routine
	169	mov r0, lr
	170	sub r0, r0, #MCOUNT_INSN_SIZE
	171	mov lr, pc
	172	mov pc, r2
	173	ldmia sp!, {r0-r3, ip, lr}
	174	mov pc, ip
181f817e	175
014c257c	176	ENTRY(mcount)
28e192d6 RV	177	stmdb sp!, {r0-r3, lr}
	178	ldr r0, =ftrace_trace_function
	179	ldr r2, [r0]
	180	adr r0, ftrace_stub
	181	cmp r0, r2
	182	bne trace
	183	ldr lr, [fp, #-4] @ restore lr
	184	ldmia sp!, {r0-r3, pc}
014c257c AS	185
014c257c AS	186	trace:
28e192d6 RV	187	ldr r1, [fp, #-4] @ lr of instrumented routine
	188	mov r0, lr
	189	sub r0, r0, #MCOUNT_INSN_SIZE
	190	mov lr, pc
	191	mov pc, r2
	192	ldr lr, [fp, #-4] @ restore lr
	193	ldmia sp!, {r0-r3, pc}
014c257c AS	194
	195	#endif /* CONFIG_DYNAMIC_FTRACE */
	196
	197	.globl ftrace_stub
	198	ftrace_stub:
28e192d6	199	mov pc, lr
014c257c	200
606576ce	201	#endif /* CONFIG_FUNCTION_TRACER */
014c257c	202
1da177e4 LT	203	/*=============================================================================
	204	* SWI handler
	205	*-----------------------------------------------------------------------------
	206	*/
	207
	208	/* If we're optimising for StrongARM the resulting code won't
	209	run on an ARM7 and we can save a couple of instructions.
	210	--pb */
	211	#ifdef CONFIG_CPU_ARM710
3f2829a3 NP	212	#define A710(code...) code
3f2829a3 NP	213	.Larm710bug:
1da177e4 LT	214	ldmia sp, {r0 - lr}^ @ Get calling r0 - lr
1da177e4 LT	215	mov r0, r0
1da177e4	216	add sp, sp, #S_FRAME_SIZE
60ac133a	217	subs pc, lr, #4
1da177e4	218	#else
3f2829a3	219	#define A710(code...)
1da177e4 LT	220	#endif
	221
	222	.align 5
	223	ENTRY(vector_swi)
f4dc9a4c RK	224	sub sp, sp, #S_FRAME_SIZE
f4dc9a4c RK	225	stmia sp, {r0 - r12} @ Calling r0 - r12
b86040a5 CM	226	ARM( add r8, sp, #S_PC )
	227	ARM( stmdb r8, {sp, lr}^ ) @ Calling sp, lr
	228	THUMB( mov r8, sp )
	229	THUMB( store_user_sp_lr r8, r10, S_SP ) @ calling sp, lr
f4dc9a4c RK	230	mrs r8, spsr @ called from non-FIQ mode, so ok.
	231	str lr, [sp, #S_PC] @ Save calling PC
	232	str r8, [sp, #S_PSR] @ Save CPSR
	233	str r0, [sp, #S_OLD_R0] @ Save OLD_R0
1da177e4	234	zero_fp
e0f9f4a6 RK	235
	236	/*
	237	* Get the system call number.
	238	*/
3f2829a3	239
dd35afc2	240	#if defined(CONFIG_OABI_COMPAT)
3f2829a3	241
dd35afc2 NP	242	/*
	243	* If we have CONFIG_OABI_COMPAT then we need to look at the swi
	244	* value to determine if it is an EABI or an old ABI call.
	245	*/
	246	#ifdef CONFIG_ARM_THUMB
	247	tst r8, #PSR_T_BIT
	248	movne r10, #0 @ no thumb OABI emulation
	249	ldreq r10, [lr, #-4] @ get SWI instruction
	250	#else
	251	ldr r10, [lr, #-4] @ get SWI instruction
	252	A710( and ip, r10, #0x0f000000 @ check for SWI )
	253	A710( teq ip, #0x0f000000 )
	254	A710( bne .Larm710bug )
	255	#endif
26584853 CM	256	#ifdef CONFIG_CPU_ENDIAN_BE8
	257	rev r10, r10 @ little endian instruction
	258	#endif
dd35afc2 NP	259
	260	#elif defined(CONFIG_AEABI)
	261
	262	/*
	263	* Pure EABI user space always put syscall number into scno (r7).
	264	*/
3f2829a3 NP	265	A710( ldr ip, [lr, #-4] @ get SWI instruction )
	266	A710( and ip, ip, #0x0f000000 @ check for SWI )
	267	A710( teq ip, #0x0f000000 )
	268	A710( bne .Larm710bug )
dd35afc2	269
3f2829a3	270	#elif defined(CONFIG_ARM_THUMB)
dd35afc2 NP	271
dd35afc2 NP	272	/* Legacy ABI only, possibly thumb mode. */
e0f9f4a6 RK	273	tst r8, #PSR_T_BIT @ this is SPSR from save_user_regs
	274	addne scno, r7, #__NR_SYSCALL_BASE @ put OS number in
	275	ldreq scno, [lr, #-4]
dd35afc2	276
e0f9f4a6	277	#else
dd35afc2 NP	278
dd35afc2 NP	279	/* Legacy ABI only. */
e0f9f4a6	280	ldr scno, [lr, #-4] @ get SWI instruction
3f2829a3 NP	281	A710( and ip, scno, #0x0f000000 @ check for SWI )
	282	A710( teq ip, #0x0f000000 )
	283	A710( bne .Larm710bug )
dd35afc2	284
e0f9f4a6	285	#endif
1da177e4 LT	286
	287	#ifdef CONFIG_ALIGNMENT_TRAP
	288	ldr ip, __cr_alignment
	289	ldr ip, [ip]
	290	mcr p15, 0, ip, c1, c0 @ update control register
	291	#endif
1ec42c0c	292	enable_irq
1da177e4	293
1da177e4	294	get_thread_info tsk
dd35afc2	295	adr tbl, sys_call_table @ load syscall table pointer
1da177e4	296	ldr ip, [tsk, #TI_FLAGS] @ check for syscall tracing
dd35afc2 NP	297
	298	#if defined(CONFIG_OABI_COMPAT)
	299	/*
	300	* If the swi argument is zero, this is an EABI call and we do nothing.
	301	*
	302	* If this is an old ABI call, get the syscall number into scno and
	303	* get the old ABI syscall table address.
	304	*/
	305	bics r10, r10, #0xff000000
	306	eorne scno, r10, #__NR_OABI_SYSCALL_BASE
	307	ldrne tbl, =sys_oabi_call_table
	308	#elif !defined(CONFIG_AEABI)
1da177e4	309	bic scno, scno, #0xff000000 @ mask off SWI op-code
e0f9f4a6	310	eor scno, scno, #__NR_SYSCALL_BASE @ check OS number
3f2829a3	311	#endif
dd35afc2	312
3f2829a3	313	stmdb sp!, {r4, r5} @ push fifth and sixth args
1da177e4 LT	314	tst ip, #_TIF_SYSCALL_TRACE @ are we tracing syscalls?
	315	bne __sys_trace
	316
1da177e4	317	cmp scno, #NR_syscalls @ check upper syscall limit
b86040a5	318	adr lr, BSYM(ret_fast_syscall) @ return address
1da177e4 LT	319	ldrcc pc, [tbl, scno, lsl #2] @ call sys_* routine
	320
	321	add r1, sp, #S_OFF
	322	2: mov why, #0 @ no longer a real syscall
e0f9f4a6 RK	323	cmp scno, #(__ARM_NR_BASE - __NR_SYSCALL_BASE)
e0f9f4a6 RK	324	eor r0, scno, #__NR_SYSCALL_BASE @ put OS number back
1da177e4 LT	325	bcs arm_syscall
1da177e4 LT	326	b sys_ni_syscall @ not private func
93ed3970	327	ENDPROC(vector_swi)
1da177e4 LT	328
	329	/*
	330	* This is the really slow path. We're going to be doing
	331	* context switches, and waiting for our parent to respond.
	332	*/
	333	__sys_trace:
3f471126	334	mov r2, scno
1da177e4 LT	335	add r1, sp, #S_OFF
	336	mov r0, #0 @ trace entry [IP = 0]
	337	bl syscall_trace
	338
b86040a5	339	adr lr, BSYM(__sys_trace_return) @ return address
3f471126	340	mov scno, r0 @ syscall number (possibly new)
1da177e4 LT	341	add r1, sp, #S_R0 + S_OFF @ pointer to regs
	342	cmp scno, #NR_syscalls @ check upper syscall limit
	343	ldmccia r1, {r0 - r3} @ have to reload r0 - r3
	344	ldrcc pc, [tbl, scno, lsl #2] @ call sys_* routine
	345	b 2b
	346
	347	__sys_trace_return:
	348	str r0, [sp, #S_R0 + S_OFF]! @ save returned r0
3f471126	349	mov r2, scno
1da177e4 LT	350	mov r1, sp
	351	mov r0, #1 @ trace exit [IP = 1]
	352	bl syscall_trace
	353	b ret_slow_syscall
	354
	355	.align 5
	356	#ifdef CONFIG_ALIGNMENT_TRAP
	357	.type __cr_alignment, #object
	358	__cr_alignment:
	359	.word cr_alignment
dd35afc2 NP	360	#endif
	361	.ltorg
	362
	363	/*
	364	* This is the syscall table declaration for native ABI syscalls.
	365	* With EABI a couple syscalls are obsolete and defined as sys_ni_syscall.
	366	*/
	367	#define ABI(native, compat) native
	368	#ifdef CONFIG_AEABI
	369	#define OBSOLETE(syscall) sys_ni_syscall
	370	#else
	371	#define OBSOLETE(syscall) syscall
1da177e4 LT	372	#endif
	373
	374	.type sys_call_table, #object
	375	ENTRY(sys_call_table)
	376	#include "calls.S"
dd35afc2 NP	377	#undef ABI
dd35afc2 NP	378	#undef OBSOLETE
1da177e4 LT	379
	380	/*============================================================================
	381	* Special system call wrappers
	382	*/
	383	@ r0 = syscall number
567bd980	384	@ r8 = syscall table
1da177e4	385	sys_syscall:
5247593c	386	bic scno, r0, #__NR_OABI_SYSCALL_BASE
1da177e4 LT	387	cmp scno, #__NR_syscall - __NR_SYSCALL_BASE
	388	cmpne scno, #NR_syscalls @ check range
	389	stmloia sp, {r5, r6} @ shuffle args
	390	movlo r0, r1
	391	movlo r1, r2
	392	movlo r2, r3
	393	movlo r3, r4
	394	ldrlo pc, [tbl, scno, lsl #2]
	395	b sys_ni_syscall
93ed3970	396	ENDPROC(sys_syscall)
1da177e4 LT	397
	398	sys_fork_wrapper:
	399	add r0, sp, #S_OFF
	400	b sys_fork
93ed3970	401	ENDPROC(sys_fork_wrapper)
1da177e4 LT	402
	403	sys_vfork_wrapper:
	404	add r0, sp, #S_OFF
	405	b sys_vfork
93ed3970	406	ENDPROC(sys_vfork_wrapper)
1da177e4 LT	407
	408	sys_execve_wrapper:
	409	add r3, sp, #S_OFF
	410	b sys_execve
93ed3970	411	ENDPROC(sys_execve_wrapper)
1da177e4 LT	412
	413	sys_clone_wrapper:
	414	add ip, sp, #S_OFF
	415	str ip, [sp, #4]
	416	b sys_clone
93ed3970	417	ENDPROC(sys_clone_wrapper)
1da177e4	418
1da177e4 LT	419	sys_sigreturn_wrapper:
	420	add r0, sp, #S_OFF
	421	b sys_sigreturn
93ed3970	422	ENDPROC(sys_sigreturn_wrapper)
1da177e4 LT	423
	424	sys_rt_sigreturn_wrapper:
	425	add r0, sp, #S_OFF
	426	b sys_rt_sigreturn
93ed3970	427	ENDPROC(sys_rt_sigreturn_wrapper)
1da177e4 LT	428
	429	sys_sigaltstack_wrapper:
	430	ldr r2, [sp, #S_OFF + S_SP]
	431	b do_sigaltstack
93ed3970	432	ENDPROC(sys_sigaltstack_wrapper)
1da177e4	433
713c4815 NP	434	sys_statfs64_wrapper:
	435	teq r1, #88
	436	moveq r1, #84
	437	b sys_statfs64
93ed3970	438	ENDPROC(sys_statfs64_wrapper)
713c4815 NP	439
	440	sys_fstatfs64_wrapper:
	441	teq r1, #88
	442	moveq r1, #84
	443	b sys_fstatfs64
93ed3970	444	ENDPROC(sys_fstatfs64_wrapper)
713c4815	445
1da177e4 LT	446	/*
	447	* Note: off_4k (r5) is always units of 4K. If we can't do the requested
	448	* offset, we return EINVAL.
	449	*/
	450	sys_mmap2:
	451	#if PAGE_SHIFT > 12
	452	tst r5, #PGOFF_MASK
	453	moveq r5, r5, lsr #PAGE_SHIFT - 12
	454	streq r5, [sp, #4]
f8b72560	455	beq sys_mmap_pgoff
1da177e4	456	mov r0, #-EINVAL
7999d8d7	457	mov pc, lr
1da177e4 LT	458	#else
1da177e4 LT	459	str r5, [sp, #4]
f8b72560	460	b sys_mmap_pgoff
1da177e4	461	#endif
93ed3970	462	ENDPROC(sys_mmap2)
687ad019 NP	463
687ad019 NP	464	#ifdef CONFIG_OABI_COMPAT
dd35afc2	465
687ad019 NP	466	/*
	467	* These are syscalls with argument register differences
	468	*/
	469
	470	sys_oabi_pread64:
	471	stmia sp, {r3, r4}
	472	b sys_pread64
93ed3970	473	ENDPROC(sys_oabi_pread64)
687ad019 NP	474
	475	sys_oabi_pwrite64:
	476	stmia sp, {r3, r4}
	477	b sys_pwrite64
93ed3970	478	ENDPROC(sys_oabi_pwrite64)
687ad019 NP	479
	480	sys_oabi_truncate64:
	481	mov r3, r2
	482	mov r2, r1
	483	b sys_truncate64
93ed3970	484	ENDPROC(sys_oabi_truncate64)
687ad019 NP	485
	486	sys_oabi_ftruncate64:
	487	mov r3, r2
	488	mov r2, r1
	489	b sys_ftruncate64
93ed3970	490	ENDPROC(sys_oabi_ftruncate64)
687ad019 NP	491
	492	sys_oabi_readahead:
	493	str r3, [sp]
	494	mov r3, r2
	495	mov r2, r1
	496	b sys_readahead
93ed3970	497	ENDPROC(sys_oabi_readahead)
687ad019	498
dd35afc2 NP	499	/*
	500	* Let's declare a second syscall table for old ABI binaries
	501	* using the compatibility syscall entries.
	502	*/
	503	#define ABI(native, compat) compat
	504	#define OBSOLETE(syscall) syscall
	505
	506	.type sys_oabi_call_table, #object
	507	ENTRY(sys_oabi_call_table)
	508	#include "calls.S"
	509	#undef ABI
	510	#undef OBSOLETE
	511
687ad019 NP	512	#endif
687ad019 NP	513