[deliverable/linux.git] / arch / c6x / kernel / entry.S

;
;  Port on Texas Instruments TMS320C6x architecture
;
;  Copyright (C) 2004-2011 Texas Instruments Incorporated
;  Author: Aurelien Jacquiot (aurelien.jacquiot@virtuallogix.com)
;  Updated for 2.6.34: Mark Salter <msalter@redhat.com>
;
;  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 <linux/sys.h>
#include <linux/linkage.h>
#include <asm/thread_info.h>
#include <asm/asm-offsets.h>
#include <asm/unistd.h>
#include <asm/errno.h>

; Registers naming
#define DP	B14
#define SP	B15

#ifndef CONFIG_PREEMPT
#define resume_kernel restore_all
#endif

	.altmacro

	.macro MASK_INT reg
	MVC	.S2	CSR,reg
	CLR	.S2	reg,0,0,reg
	MVC	.S2	reg,CSR
	.endm

	.macro UNMASK_INT reg
	MVC	.S2	CSR,reg
	SET	.S2	reg,0,0,reg
	MVC	.S2	reg,CSR
	.endm

	.macro GET_THREAD_INFO reg
	SHR	.S1X	SP,THREAD_SHIFT,reg
	SHL	.S1	reg,THREAD_SHIFT,reg
	.endm

	;;
	;;  This defines the normal kernel pt_regs layout.
	;;
	.macro SAVE_ALL __rp __tsr
	STW	.D2T2	B0,*SP--[2]		; save original B0
	MVKL	.S2	current_ksp,B0
	MVKH	.S2	current_ksp,B0
	LDW	.D2T2	*B0,B1			; KSP

	NOP	3
	STW	.D2T2	B1,*+SP[1]		; save original B1
	XOR	.D2	SP,B1,B0		; (SP ^ KSP)
	LDW	.D2T2	*+SP[1],B1		; restore B0/B1
	LDW	.D2T2	*++SP[2],B0
	SHR	.S2	B0,THREAD_SHIFT,B0	; 0 if already using kstack
  [B0]	STDW	.D2T2	SP:DP,*--B1[1]		; user: save user sp/dp kstack
  [B0]	MV	.S2	B1,SP			;    and switch to kstack
||[!B0] STDW	.D2T2	SP:DP,*--SP[1]		; kernel: save on current stack

	SUBAW	.D2	SP,2,SP

	ADD	.D1X	SP,-8,A15
 ||	STDW	.D2T1	A15:A14,*SP--[16]	; save A15:A14

	STDW	.D2T2	B13:B12,*SP--[1]
 ||	STDW	.D1T1	A13:A12,*A15--[1]
 ||	MVC	.S2	__rp,B13

	STDW	.D2T2	B11:B10,*SP--[1]
 ||	STDW	.D1T1	A11:A10,*A15--[1]
 ||	MVC	.S2	CSR,B12

	STDW	.D2T2	B9:B8,*SP--[1]
 ||	STDW	.D1T1	A9:A8,*A15--[1]
 ||	MVC	.S2	RILC,B11
	STDW	.D2T2	B7:B6,*SP--[1]
 ||	STDW	.D1T1	A7:A6,*A15--[1]
 ||	MVC	.S2	ILC,B10

	STDW	.D2T2	B5:B4,*SP--[1]
 ||	STDW	.D1T1	A5:A4,*A15--[1]

	STDW	.D2T2	B3:B2,*SP--[1]
 ||	STDW	.D1T1	A3:A2,*A15--[1]
 ||	MVC	.S2	__tsr,B5

	STDW	.D2T2	B1:B0,*SP--[1]
 ||	STDW	.D1T1	A1:A0,*A15--[1]
 ||	MV	.S1X	B5,A5

	STDW	.D2T2	B31:B30,*SP--[1]
 ||	STDW	.D1T1	A31:A30,*A15--[1]
	STDW	.D2T2	B29:B28,*SP--[1]
 ||	STDW	.D1T1	A29:A28,*A15--[1]
	STDW	.D2T2	B27:B26,*SP--[1]
 ||	STDW	.D1T1	A27:A26,*A15--[1]
	STDW	.D2T2	B25:B24,*SP--[1]
 ||	STDW	.D1T1	A25:A24,*A15--[1]
	STDW	.D2T2	B23:B22,*SP--[1]
 ||	STDW	.D1T1	A23:A22,*A15--[1]
	STDW	.D2T2	B21:B20,*SP--[1]
 ||	STDW	.D1T1	A21:A20,*A15--[1]
	STDW	.D2T2	B19:B18,*SP--[1]
 ||	STDW	.D1T1	A19:A18,*A15--[1]
	STDW	.D2T2	B17:B16,*SP--[1]
 ||	STDW	.D1T1	A17:A16,*A15--[1]

	STDW	.D2T2	B13:B12,*SP--[1]	; save PC and CSR

	STDW	.D2T2	B11:B10,*SP--[1]	; save RILC and ILC
	STDW	.D2T1	A5:A4,*SP--[1]		; save TSR and orig A4

	;; We left an unused word on the stack just above pt_regs.
	;; It is used to save whether or not this frame is due to
	;; a syscall. It is cleared here, but the syscall handler
	;; sets it to a non-zero value.
	MVK	.L2	0,B1
	STW	.D2T2	B1,*+SP(REGS__END+8)	; clear syscall flag
	.endm

	.macro RESTORE_ALL __rp __tsr
	LDDW	.D2T2	*++SP[1],B9:B8		; get TSR (B9)
	LDDW	.D2T2	*++SP[1],B11:B10	; get RILC (B11) and ILC (B10)
	LDDW	.D2T2	*++SP[1],B13:B12	; get PC (B13) and CSR (B12)

	ADDAW	.D1X	SP,30,A15

	LDDW	.D1T1	*++A15[1],A17:A16
 ||	LDDW	.D2T2	*++SP[1],B17:B16
	LDDW	.D1T1	*++A15[1],A19:A18
 ||	LDDW	.D2T2	*++SP[1],B19:B18
	LDDW	.D1T1	*++A15[1],A21:A20
 ||	LDDW	.D2T2	*++SP[1],B21:B20
	LDDW	.D1T1	*++A15[1],A23:A22
 ||	LDDW	.D2T2	*++SP[1],B23:B22
	LDDW	.D1T1	*++A15[1],A25:A24
 ||	LDDW	.D2T2	*++SP[1],B25:B24
	LDDW	.D1T1	*++A15[1],A27:A26
 ||	LDDW	.D2T2	*++SP[1],B27:B26
	LDDW	.D1T1	*++A15[1],A29:A28
 ||	LDDW	.D2T2	*++SP[1],B29:B28
	LDDW	.D1T1	*++A15[1],A31:A30
 ||	LDDW	.D2T2	*++SP[1],B31:B30

	LDDW	.D1T1	*++A15[1],A1:A0
 ||	LDDW	.D2T2	*++SP[1],B1:B0

	LDDW	.D1T1	*++A15[1],A3:A2
 ||	LDDW	.D2T2	*++SP[1],B3:B2
 ||	MVC	.S2	B9,__tsr
	LDDW	.D1T1	*++A15[1],A5:A4
 ||	LDDW	.D2T2	*++SP[1],B5:B4
 ||	MVC	.S2	B11,RILC
	LDDW	.D1T1	*++A15[1],A7:A6
 ||	LDDW	.D2T2	*++SP[1],B7:B6
 ||	MVC	.S2	B10,ILC

	LDDW	.D1T1	*++A15[1],A9:A8
 ||	LDDW	.D2T2	*++SP[1],B9:B8
 ||	MVC	.S2	B13,__rp

	LDDW	.D1T1	*++A15[1],A11:A10
 ||	LDDW	.D2T2	*++SP[1],B11:B10
 ||	MVC	.S2	B12,CSR

	LDDW	.D1T1	*++A15[1],A13:A12
 ||	LDDW	.D2T2	*++SP[1],B13:B12

	MV	.D2X	A15,SP
 ||	MVKL	.S1	current_ksp,A15
	MVKH	.S1	current_ksp,A15
 ||	ADDAW	.D1X	SP,6,A14
	STW	.D1T1	A14,*A15	; save kernel stack pointer

	LDDW	.D2T1	*++SP[1],A15:A14

	B	.S2	__rp		; return from interruption
	LDDW	.D2T2	*+SP[1],SP:DP
	NOP	4
	.endm

	.section .text

	;;
	;; Jump to schedule() then return to ret_from_exception
	;;
_reschedule:
#ifdef CONFIG_C6X_BIG_KERNEL
	MVKL	.S1	schedule,A0
	MVKH	.S1	schedule,A0
	B	.S2X	A0
#else
	B	.S1	schedule
#endif
	ADDKPC	.S2	ret_from_exception,B3,4

	;;
	;; Called before syscall handler when process is being debugged
	;;
tracesys_on:
#ifdef CONFIG_C6X_BIG_KERNEL
	MVKL	.S1	syscall_trace_entry,A0
	MVKH	.S1	syscall_trace_entry,A0
	B	.S2X	A0
#else
	B	.S1	syscall_trace_entry
#endif
	ADDKPC	.S2	ret_from_syscall_trace,B3,3
	ADD	.S1X	8,SP,A4

ret_from_syscall_trace:
	;; tracing returns (possibly new) syscall number
	MV	.D2X	A4,B0
 ||	MVK	.S2	__NR_syscalls,B1
	CMPLTU	.L2	B0,B1,B1

 [!B1]	BNOP	.S2	ret_from_syscall_function,5
 ||	MVK	.S1	-ENOSYS,A4

	;; reload syscall args from (possibly modified) stack frame
	;; and get syscall handler addr from sys_call_table:
	LDW	.D2T2	*+SP(REGS_B4+8),B4
 ||	MVKL	.S2	sys_call_table,B1
	LDW	.D2T1	*+SP(REGS_A6+8),A6
 ||	MVKH	.S2	sys_call_table,B1
	LDW	.D2T2	*+B1[B0],B0
 ||	MVKL	.S2	ret_from_syscall_function,B3
	LDW	.D2T2	*+SP(REGS_B6+8),B6
 ||	MVKH	.S2	ret_from_syscall_function,B3
	LDW	.D2T1	*+SP(REGS_A8+8),A8
	LDW	.D2T2	*+SP(REGS_B8+8),B8
	NOP
	; B0 = sys_call_table[__NR_*]
	BNOP	.S2	B0,5			; branch to syscall handler
 ||	LDW	.D2T1	*+SP(REGS_ORIG_A4+8),A4

syscall_exit_work:
	AND	.D1	_TIF_SYSCALL_TRACE,A2,A0
 [!A0]	BNOP	.S1	work_pending,5
 [A0]	B	.S2	syscall_trace_exit
	ADDKPC	.S2	resume_userspace,B3,1
	MVC	.S2	CSR,B1
	SET	.S2	B1,0,0,B1
	MVC	.S2	B1,CSR		; enable ints

work_pending:
	AND	.D1	_TIF_NEED_RESCHED,A2,A0
 [!A0]	BNOP	.S1	work_notifysig,5

work_resched:
#ifdef CONFIG_C6X_BIG_KERNEL
	MVKL	.S1	schedule,A1
	MVKH	.S1	schedule,A1
	B	.S2X	A1
#else
	B	.S2	schedule
#endif
	ADDKPC	.S2	work_rescheduled,B3,4
work_rescheduled:
	;; make sure we don't miss an interrupt setting need_resched or
	;; sigpending between sampling and the rti
	MASK_INT B2
	GET_THREAD_INFO A12
	LDW	.D1T1	*+A12(THREAD_INFO_FLAGS),A2
	MVK	.S1	_TIF_WORK_MASK,A1
	MVK	.S1	_TIF_NEED_RESCHED,A3
	NOP	2
	AND	.D1	A1,A2,A0
 ||	AND	.S1	A3,A2,A1
 [!A0]	BNOP	.S1	restore_all,5
 [A1]	BNOP	.S1	work_resched,5

work_notifysig:
	;; enable interrupts for do_notify_resume()
	UNMASK_INT B2
	B	.S2	do_notify_resume
	LDW	.D2T1	*+SP(REGS__END+8),A6 ; syscall flag
	ADDKPC	.S2	resume_userspace,B3,1
	ADD	.S1X	8,SP,A4		; pt_regs pointer is first arg
	MV	.D2X	A2,B4		; thread_info flags is second arg

	;;
	;; On C64x+, the return way from exception and interrupt
	;; is a little bit different
	;;
ENTRY(ret_from_exception)
#ifdef CONFIG_PREEMPT
	MASK_INT B2
#endif

ENTRY(ret_from_interrupt)
	;;
	;; Check if we are comming from user mode.
	;;
	LDW	.D2T2	*+SP(REGS_TSR+8),B0
	MVK	.S2	0x40,B1
	NOP	3
	AND	.D2	B0,B1,B0
 [!B0]	BNOP	.S2	resume_kernel,5

resume_userspace:
	;; make sure we don't miss an interrupt setting need_resched or
	;; sigpending between sampling and the rti
	MASK_INT B2
	GET_THREAD_INFO A12
	LDW	.D1T1	*+A12(THREAD_INFO_FLAGS),A2
	MVK	.S1	_TIF_WORK_MASK,A1
	MVK	.S1	_TIF_NEED_RESCHED,A3
	NOP	2
	AND	.D1	A1,A2,A0
 [A0]	BNOP	.S1	work_pending,5
	BNOP	.S1	restore_all,5

	;;
	;; System call handling
	;; B0 = syscall number (in sys_call_table)
	;; A4,B4,A6,B6,A8,B8 = arguments of the syscall function
	;; A4 is the return value register
	;;
system_call_saved:
	MVK	.L2	1,B2
	STW	.D2T2	B2,*+SP(REGS__END+8)	; set syscall flag
	MVC	.S2	B2,ECR			; ack the software exception

	UNMASK_INT B2			; re-enable global IT

system_call_saved_noack:
	;; Check system call number
	MVK	.S2	__NR_syscalls,B1
#ifdef CONFIG_C6X_BIG_KERNEL
 ||	MVKL	.S1	sys_ni_syscall,A0
#endif
	CMPLTU	.L2	B0,B1,B1
#ifdef CONFIG_C6X_BIG_KERNEL
 ||	MVKH	.S1	sys_ni_syscall,A0
#endif

	;; Check for ptrace
	GET_THREAD_INFO A12

#ifdef CONFIG_C6X_BIG_KERNEL
 [!B1]	B	.S2X	A0
#else
 [!B1]	B	.S2	sys_ni_syscall
#endif
 [!B1]	ADDKPC	.S2	ret_from_syscall_function,B3,4

	;; Get syscall handler addr from sys_call_table
	;; call tracesys_on or call syscall handler
	LDW	.D1T1	*+A12(THREAD_INFO_FLAGS),A2
 ||	MVKL	.S2	sys_call_table,B1
	MVKH	.S2	sys_call_table,B1
	LDW	.D2T2	*+B1[B0],B0
	NOP	2
	; A2 = thread_info flags
	AND	.D1	_TIF_SYSCALL_TRACE,A2,A2
 [A2]	BNOP	.S1	tracesys_on,5
	;; B0 = _sys_call_table[__NR_*]
	B	.S2	B0
	ADDKPC	.S2	ret_from_syscall_function,B3,4

ret_from_syscall_function:
	STW	.D2T1	A4,*+SP(REGS_A4+8)	; save return value in A4
						; original A4 is in orig_A4
syscall_exit:
	;; make sure we don't miss an interrupt setting need_resched or
	;; sigpending between sampling and the rti
	MASK_INT B2
	LDW	.D1T1	*+A12(THREAD_INFO_FLAGS),A2
	MVK	.S1	_TIF_ALLWORK_MASK,A1
	NOP	3
	AND	.D1	A1,A2,A2 ; check for work to do
 [A2]	BNOP	.S1	syscall_exit_work,5

restore_all:
	RESTORE_ALL NRP,NTSR

	;;
	;; After a fork we jump here directly from resume,
	;; so that A4 contains the previous task structure.
	;;
ENTRY(ret_from_fork)
#ifdef CONFIG_C6X_BIG_KERNEL
	MVKL	.S1	schedule_tail,A0
	MVKH	.S1	schedule_tail,A0
	B	.S2X	A0
#else
	B	.S2	schedule_tail
#endif
	ADDKPC	.S2	ret_from_fork_2,B3,4
ret_from_fork_2:
	;; return 0 in A4 for child process
	GET_THREAD_INFO A12
	BNOP	.S2	syscall_exit,3
	MVK	.L2	0,B0
	STW	.D2T2	B0,*+SP(REGS_A4+8)
ENDPROC(ret_from_fork)

ENTRY(ret_from_kernel_thread)
#ifdef CONFIG_C6X_BIG_KERNEL
	MVKL	.S1	schedule_tail,A0
	MVKH	.S1	schedule_tail,A0
	B	.S2X	A0
#else
	B	.S2	schedule_tail
#endif
	LDW	.D2T2	*+SP(REGS_A0+8),B10 /* get fn  */
	ADDKPC	.S2	0f,B3,3
0:
	B	.S2	B10		   /* call fn */
	LDW	.D2T1	*+SP(REGS_A1+8),A4 /* get arg */
	MVKL	.S2	sys_exit,B11
	MVKH	.S2	sys_exit,B11
	ADDKPC	.S2	0f,B3,1
0:
	BNOP	.S2	B11,5	/* jump to sys_exit */
ENDPROC(ret_from_kernel_thread)

ENTRY(ret_from_kernel_execve)
	GET_THREAD_INFO A12
	BNOP	.S2	syscall_exit,4
	ADD	.D2X	A4,-8,SP
ENDPROC(ret_from_kernel_execve)

	;;
	;; These are the interrupt handlers, responsible for calling __do_IRQ()
	;; int6 is used for syscalls (see _system_call entry)
	;;
	.macro SAVE_ALL_INT
	SAVE_ALL IRP,ITSR
	.endm

	.macro CALL_INT int
#ifdef CONFIG_C6X_BIG_KERNEL
	MVKL	.S1	c6x_do_IRQ,A0
	MVKH	.S1	c6x_do_IRQ,A0
	BNOP	.S2X	A0,1
	MVK	.S1	int,A4
	ADDAW	.D2	SP,2,B4
	MVKL	.S2	ret_from_interrupt,B3
	MVKH	.S2	ret_from_interrupt,B3
#else
	CALLP   .S2	c6x_do_IRQ,B3
 ||	MVK	.S1	int,A4
 ||	ADDAW	.D2	SP,2,B4
	B	.S1	ret_from_interrupt
	NOP	5
#endif
	.endm

ENTRY(_int4_handler)
	SAVE_ALL_INT
	CALL_INT 4
ENDPROC(_int4_handler)

ENTRY(_int5_handler)
	SAVE_ALL_INT
	CALL_INT 5
ENDPROC(_int5_handler)

ENTRY(_int6_handler)
	SAVE_ALL_INT
	CALL_INT 6
ENDPROC(_int6_handler)

ENTRY(_int7_handler)
	SAVE_ALL_INT
	CALL_INT 7
ENDPROC(_int7_handler)

ENTRY(_int8_handler)
	SAVE_ALL_INT
	CALL_INT 8
ENDPROC(_int8_handler)

ENTRY(_int9_handler)
	SAVE_ALL_INT
	CALL_INT 9
ENDPROC(_int9_handler)

ENTRY(_int10_handler)
	SAVE_ALL_INT
	CALL_INT 10
ENDPROC(_int10_handler)

ENTRY(_int11_handler)
	SAVE_ALL_INT
	CALL_INT 11
ENDPROC(_int11_handler)

ENTRY(_int12_handler)
	SAVE_ALL_INT
	CALL_INT 12
ENDPROC(_int12_handler)

ENTRY(_int13_handler)
	SAVE_ALL_INT
	CALL_INT 13
ENDPROC(_int13_handler)

ENTRY(_int14_handler)
	SAVE_ALL_INT
	CALL_INT 14
ENDPROC(_int14_handler)

ENTRY(_int15_handler)
	SAVE_ALL_INT
	CALL_INT 15
ENDPROC(_int15_handler)

	;;
	;; Handler for uninitialized and spurious interrupts
	;;
ENTRY(_bad_interrupt)
	B	.S2	IRP
	NOP	5
ENDPROC(_bad_interrupt)

	;;
	;; Entry for NMI/exceptions/syscall
	;;
ENTRY(_nmi_handler)
	SAVE_ALL NRP,NTSR

	MVC	.S2	EFR,B2
	CMPEQ	.L2	1,B2,B2
 ||	MVC	.S2	TSR,B1
	CLR	.S2	B1,10,10,B1
	MVC	.S2	B1,TSR
#ifdef CONFIG_C6X_BIG_KERNEL
 [!B2]	MVKL	.S1	process_exception,A0
 [!B2]	MVKH	.S1	process_exception,A0
 [!B2]	B	.S2X	A0
#else
 [!B2]	B	.S2	process_exception
#endif
 [B2]	B	.S2	system_call_saved
 [!B2]	ADDAW	.D2	SP,2,B1
 [!B2]	MV	.D1X	B1,A4
	ADDKPC	.S2	ret_from_trap,B3,2

ret_from_trap:
	MV	.D2X	A4,B0
 [!B0]	BNOP	.S2	ret_from_exception,5

#ifdef CONFIG_C6X_BIG_KERNEL
	MVKL	.S2	system_call_saved_noack,B3
	MVKH	.S2	system_call_saved_noack,B3
#endif
	LDW	.D2T2	*+SP(REGS_B0+8),B0
	LDW	.D2T1	*+SP(REGS_A4+8),A4
	LDW	.D2T2	*+SP(REGS_B4+8),B4
	LDW	.D2T1	*+SP(REGS_A6+8),A6
	LDW	.D2T2	*+SP(REGS_B6+8),B6
	LDW	.D2T1	*+SP(REGS_A8+8),A8
#ifdef CONFIG_C6X_BIG_KERNEL
 ||	B	.S2	B3
#else
 ||	B	.S2	system_call_saved_noack
#endif
	LDW	.D2T2	*+SP(REGS_B8+8),B8
	NOP	4
ENDPROC(_nmi_handler)

	;;
	;; Jump to schedule() then return to ret_from_isr
	;;
#ifdef	CONFIG_PREEMPT
resume_kernel:
	GET_THREAD_INFO A12
	LDW	.D1T1	*+A12(THREAD_INFO_PREEMPT_COUNT),A1
	NOP	4
 [A1]	BNOP	.S2	restore_all,5

preempt_schedule:
	GET_THREAD_INFO A2
	LDW	.D1T1	*+A2(THREAD_INFO_FLAGS),A1
#ifdef CONFIG_C6X_BIG_KERNEL
	MVKL	.S2	preempt_schedule_irq,B0
	MVKH	.S2	preempt_schedule_irq,B0
	NOP	2
#else
	NOP	4
#endif
	AND	.D1	_TIF_NEED_RESCHED,A1,A1
 [!A1]	BNOP	.S2	restore_all,5
#ifdef CONFIG_C6X_BIG_KERNEL
	B	.S2	B0
#else
	B	.S2	preempt_schedule_irq
#endif
	ADDKPC	.S2	preempt_schedule,B3,4
#endif /* CONFIG_PREEMPT */

ENTRY(enable_exception)
	DINT
	MVC	.S2	TSR,B0
	MVC	.S2	B3,NRP
	MVK	.L2	0xc,B1
	OR	.D2	B0,B1,B0
	MVC	.S2	B0,TSR			;  Set GEE and XEN in TSR
	B	.S2	NRP
	NOP	5
ENDPROC(enable_exception)

ENTRY(sys_sigaltstack)
#ifdef CONFIG_C6X_BIG_KERNEL
	MVKL	.S1	do_sigaltstack,A0	; branch to do_sigaltstack
	MVKH	.S1	do_sigaltstack,A0
	B	.S2X	A0
#else
	B	.S2	do_sigaltstack
#endif
	LDW	.D2T1	*+SP(REGS_SP+8),A6
	NOP	4
ENDPROC(sys_sigaltstack)

	;;
	;; Special system calls
	;; return address is in B3
	;;
ENTRY(sys_clone)
	ADD	.D1X	SP,8,A4
#ifdef CONFIG_C6X_BIG_KERNEL
 ||	MVKL	.S1	sys_c6x_clone,A0
	MVKH	.S1	sys_c6x_clone,A0
	BNOP	.S2X	A0,5
#else
 ||	B	.S2	sys_c6x_clone
	NOP	5
#endif
ENDPROC(sys_clone)

ENTRY(sys_rt_sigreturn)
	ADD	.D1X	SP,8,A4
#ifdef CONFIG_C6X_BIG_KERNEL
 ||	MVKL	.S1	do_rt_sigreturn,A0
	MVKH	.S1	do_rt_sigreturn,A0
	BNOP	.S2X	A0,5
#else
 ||	B	.S2	do_rt_sigreturn
	NOP	5
#endif
ENDPROC(sys_rt_sigreturn)

ENTRY(sys_pread_c6x)
	MV	.D2X	A8,B7
#ifdef CONFIG_C6X_BIG_KERNEL
 ||	MVKL	.S1	sys_pread64,A0
	MVKH	.S1	sys_pread64,A0
	BNOP	.S2X	A0,5
#else
 ||	B	.S2	sys_pread64
	NOP	5
#endif
ENDPROC(sys_pread_c6x)

ENTRY(sys_pwrite_c6x)
	MV	.D2X	A8,B7
#ifdef CONFIG_C6X_BIG_KERNEL
 ||	MVKL	.S1	sys_pwrite64,A0
	MVKH	.S1	sys_pwrite64,A0
	BNOP	.S2X	A0,5
#else
 ||	B	.S2	sys_pwrite64
	NOP	5
#endif
ENDPROC(sys_pwrite_c6x)

;; On Entry
;;   A4 - path
;;   B4 - offset_lo (LE), offset_hi (BE)
;;   A6 - offset_lo (BE), offset_hi (LE)
ENTRY(sys_truncate64_c6x)
#ifdef CONFIG_CPU_BIG_ENDIAN
	MV	.S2	B4,B5
	MV	.D2X	A6,B4
#else
	MV	.D2X	A6,B5
#endif
#ifdef CONFIG_C6X_BIG_KERNEL
 ||	MVKL	.S1	sys_truncate64,A0
	MVKH	.S1	sys_truncate64,A0
	BNOP	.S2X	A0,5
#else
 ||	B	.S2	sys_truncate64
	NOP	5
#endif
ENDPROC(sys_truncate64_c6x)

;; On Entry
;;   A4 - fd
;;   B4 - offset_lo (LE), offset_hi (BE)
;;   A6 - offset_lo (BE), offset_hi (LE)
ENTRY(sys_ftruncate64_c6x)
#ifdef CONFIG_CPU_BIG_ENDIAN
	MV	.S2	B4,B5
	MV	.D2X	A6,B4
#else
	MV	.D2X	A6,B5
#endif
#ifdef CONFIG_C6X_BIG_KERNEL
 ||	MVKL	.S1	sys_ftruncate64,A0
	MVKH	.S1	sys_ftruncate64,A0
	BNOP	.S2X	A0,5
#else
 ||	B	.S2	sys_ftruncate64
	NOP	5
#endif
ENDPROC(sys_ftruncate64_c6x)

;; On Entry
;;   A4 - fd
;;   B4 - offset_lo (LE), offset_hi (BE)
;;   A6 - offset_lo (BE), offset_hi (LE)
;;   B6 - len_lo (LE), len_hi (BE)
;;   A8 - len_lo (BE), len_hi (LE)
;;   B8 - advice
ENTRY(sys_fadvise64_64_c6x)
#ifdef CONFIG_C6X_BIG_KERNEL
	MVKL	.S1	sys_fadvise64_64,A0
	MVKH	.S1	sys_fadvise64_64,A0
	BNOP	.S2X	A0,2
#else
	B	.S2	sys_fadvise64_64
	NOP	2
#endif
#ifdef CONFIG_CPU_BIG_ENDIAN
	MV	.L2	B4,B5
 ||	MV	.D2X	A6,B4
	MV	.L1	A8,A6
 ||	MV	.D1X	B6,A7
#else
	MV	.D2X	A6,B5
	MV	.L1	A8,A7
 ||	MV	.D1X	B6,A6
#endif
	MV	.L2	B8,B6
ENDPROC(sys_fadvise64_64_c6x)

;; On Entry
;;   A4 - fd
;;   B4 - mode
;;   A6 - offset_hi
;;   B6 - offset_lo
;;   A8 - len_hi
;;   B8 - len_lo
ENTRY(sys_fallocate_c6x)
#ifdef CONFIG_C6X_BIG_KERNEL
	MVKL	.S1	sys_fallocate,A0
	MVKH	.S1	sys_fallocate,A0
	BNOP	.S2X	A0,1
#else
	B	.S2	sys_fallocate
	NOP
#endif
	MV	.D1	A6,A7
	MV	.D1X	B6,A6
	MV	.D2X	A8,B7
	MV	.D2	B8,B6
ENDPROC(sys_fallocate_c6x)

	;; put this in .neardata for faster access when using DSBT mode
	.section .neardata,"aw",@progbits
	.global	current_ksp
	.hidden	current_ksp
current_ksp:
	.word	init_thread_union + THREAD_START_SP
Commit	Line	Data
e94e6682 AJ	1	;
	2	; Port on Texas Instruments TMS320C6x architecture
	3	;
	4	; Copyright (C) 2004-2011 Texas Instruments Incorporated
	5	; Author: Aurelien Jacquiot (aurelien.jacquiot@virtuallogix.com)
	6	; Updated for 2.6.34: Mark Salter <msalter@redhat.com>
	7	;
	8	; This program is free software; you can redistribute it and/or modify
	9	; it under the terms of the GNU General Public License version 2 as
	10	; published by the Free Software Foundation.
	11	;
	12
	13	#include <linux/sys.h>
	14	#include <linux/linkage.h>
	15	#include <asm/thread_info.h>
	16	#include <asm/asm-offsets.h>
	17	#include <asm/unistd.h>
	18	#include <asm/errno.h>
	19
	20	; Registers naming
	21	#define DP B14
	22	#define SP B15
	23
	24	#ifndef CONFIG_PREEMPT
	25	#define resume_kernel restore_all
	26	#endif
	27
	28	.altmacro
	29
	30	.macro MASK_INT reg
	31	MVC .S2 CSR,reg
	32	CLR .S2 reg,0,0,reg
	33	MVC .S2 reg,CSR
	34	.endm
	35
	36	.macro UNMASK_INT reg
	37	MVC .S2 CSR,reg
	38	SET .S2 reg,0,0,reg
	39	MVC .S2 reg,CSR
	40	.endm
	41
	42	.macro GET_THREAD_INFO reg
	43	SHR .S1X SP,THREAD_SHIFT,reg
	44	SHL .S1 reg,THREAD_SHIFT,reg
	45	.endm
	46
	47	;;
	48	;; This defines the normal kernel pt_regs layout.
	49	;;
	50	.macro SAVE_ALL __rp __tsr
	51	STW .D2T2 B0,*SP--[2] ; save original B0
	52	MVKL .S2 current_ksp,B0
	53	MVKH .S2 current_ksp,B0
	54	LDW .D2T2 *B0,B1 ; KSP
	55
	56	NOP 3
	57	STW .D2T2 B1,*+SP[1] ; save original B1
	58	XOR .D2 SP,B1,B0 ; (SP ^ KSP)
	59	LDW .D2T2 *+SP[1],B1 ; restore B0/B1
	60	LDW .D2T2 *++SP[2],B0
	61	SHR .S2 B0,THREAD_SHIFT,B0 ; 0 if already using kstack
	62	[B0] STDW .D2T2 SP:DP,*--B1[1] ; user: save user sp/dp kstack
	63	[B0] MV .S2 B1,SP ; and switch to kstack
	64	\|\|[!B0] STDW .D2T2 SP:DP,*--SP[1] ; kernel: save on current stack
65
66	SUBAW .D2 SP,2,SP
67
68	ADD .D1X SP,-8,A15
69	\|\| STDW .D2T1 A15:A14,*SP--[16] ; save A15:A14
70
71	STDW .D2T2 B13:B12,*SP--[1]
72	\|\| STDW .D1T1 A13:A12,*A15--[1]
73	\|\| MVC .S2 __rp,B13
74
75	STDW .D2T2 B11:B10,*SP--[1]
76	\|\| STDW .D1T1 A11:A10,*A15--[1]
77	\|\| MVC .S2 CSR,B12
78
79	STDW .D2T2 B9:B8,*SP--[1]
80	\|\| STDW .D1T1 A9:A8,*A15--[1]
81	\|\| MVC .S2 RILC,B11
82	STDW .D2T2 B7:B6,*SP--[1]
83	\|\| STDW .D1T1 A7:A6,*A15--[1]
84	\|\| MVC .S2 ILC,B10
85
86	STDW .D2T2 B5:B4,*SP--[1]
87	\|\| STDW .D1T1 A5:A4,*A15--[1]
88
89	STDW .D2T2 B3:B2,*SP--[1]
90	\|\| STDW .D1T1 A3:A2,*A15--[1]
91	\|\| MVC .S2 __tsr,B5
92
93	STDW .D2T2 B1:B0,*SP--[1]
94	\|\| STDW .D1T1 A1:A0,*A15--[1]
95	\|\| MV .S1X B5,A5
96
97	STDW .D2T2 B31:B30,*SP--[1]
98	\|\| STDW .D1T1 A31:A30,*A15--[1]
99	STDW .D2T2 B29:B28,*SP--[1]
100	\|\| STDW .D1T1 A29:A28,*A15--[1]
101	STDW .D2T2 B27:B26,*SP--[1]
102	\|\| STDW .D1T1 A27:A26,*A15--[1]
103	STDW .D2T2 B25:B24,*SP--[1]
104	\|\| STDW .D1T1 A25:A24,*A15--[1]
105	STDW .D2T2 B23:B22,*SP--[1]
106	\|\| STDW .D1T1 A23:A22,*A15--[1]
107	STDW .D2T2 B21:B20,*SP--[1]
108	\|\| STDW .D1T1 A21:A20,*A15--[1]
109	STDW .D2T2 B19:B18,*SP--[1]
110	\|\| STDW .D1T1 A19:A18,*A15--[1]
111	STDW .D2T2 B17:B16,*SP--[1]
112	\|\| STDW .D1T1 A17:A16,*A15--[1]
113
114	STDW .D2T2 B13:B12,*SP--[1] ; save PC and CSR
115
116	STDW .D2T2 B11:B10,*SP--[1] ; save RILC and ILC
117	STDW .D2T1 A5:A4,*SP--[1] ; save TSR and orig A4
118
119	;; We left an unused word on the stack just above pt_regs.
120	;; It is used to save whether or not this frame is due to
121	;; a syscall. It is cleared here, but the syscall handler
122	;; sets it to a non-zero value.
123	MVK .L2 0,B1
124	STW .D2T2 B1,*+SP(REGS__END+8) ; clear syscall flag
125	.endm
126
127	.macro RESTORE_ALL __rp __tsr
128	LDDW .D2T2 *++SP[1],B9:B8 ; get TSR (B9)
129	LDDW .D2T2 *++SP[1],B11:B10 ; get RILC (B11) and ILC (B10)
130	LDDW .D2T2 *++SP[1],B13:B12 ; get PC (B13) and CSR (B12)
131
132	ADDAW .D1X SP,30,A15
133
134	LDDW .D1T1 *++A15[1],A17:A16
135	\|\| LDDW .D2T2 *++SP[1],B17:B16
136	LDDW .D1T1 *++A15[1],A19:A18
137	\|\| LDDW .D2T2 *++SP[1],B19:B18
138	LDDW .D1T1 *++A15[1],A21:A20
139	\|\| LDDW .D2T2 *++SP[1],B21:B20
140	LDDW .D1T1 *++A15[1],A23:A22
141	\|\| LDDW .D2T2 *++SP[1],B23:B22
142	LDDW .D1T1 *++A15[1],A25:A24
143	\|\| LDDW .D2T2 *++SP[1],B25:B24
144	LDDW .D1T1 *++A15[1],A27:A26
145	\|\| LDDW .D2T2 *++SP[1],B27:B26
146	LDDW .D1T1 *++A15[1],A29:A28
147	\|\| LDDW .D2T2 *++SP[1],B29:B28
148	LDDW .D1T1 *++A15[1],A31:A30
149	\|\| LDDW .D2T2 *++SP[1],B31:B30
150
151	LDDW .D1T1 *++A15[1],A1:A0
152	\|\| LDDW .D2T2 *++SP[1],B1:B0
153
154	LDDW .D1T1 *++A15[1],A3:A2
155	\|\| LDDW .D2T2 *++SP[1],B3:B2
156	\|\| MVC .S2 B9,__tsr
157	LDDW .D1T1 *++A15[1],A5:A4
158	\|\| LDDW .D2T2 *++SP[1],B5:B4
159	\|\| MVC .S2 B11,RILC
160	LDDW .D1T1 *++A15[1],A7:A6
161	\|\| LDDW .D2T2 *++SP[1],B7:B6
162	\|\| MVC .S2 B10,ILC
163
164	LDDW .D1T1 *++A15[1],A9:A8
165	\|\| LDDW .D2T2 *++SP[1],B9:B8
166	\|\| MVC .S2 B13,__rp
167
168	LDDW .D1T1 *++A15[1],A11:A10
169	\|\| LDDW .D2T2 *++SP[1],B11:B10
170	\|\| MVC .S2 B12,CSR
171
172	LDDW .D1T1 *++A15[1],A13:A12
173	\|\| LDDW .D2T2 *++SP[1],B13:B12
174
175	MV .D2X A15,SP
176	\|\| MVKL .S1 current_ksp,A15
177	MVKH .S1 current_ksp,A15
178	\|\| ADDAW .D1X SP,6,A14
179	STW .D1T1 A14,*A15 ; save kernel stack pointer
180
181	LDDW .D2T1 *++SP[1],A15:A14
182
183	B .S2 __rp ; return from interruption
184	LDDW .D2T2 *+SP[1],SP:DP
185	NOP 4
186	.endm
187
188	.section .text
189
190	;;
191	;; Jump to schedule() then return to ret_from_exception
192	;;
193	_reschedule:
194	#ifdef CONFIG_C6X_BIG_KERNEL
195	MVKL .S1 schedule,A0
196	MVKH .S1 schedule,A0
197	B .S2X A0
198	#else
199	B .S1 schedule
200	#endif
201	ADDKPC .S2 ret_from_exception,B3,4
202
203	;;
204	;; Called before syscall handler when process is being debugged
205	;;
206	tracesys_on:
207	#ifdef CONFIG_C6X_BIG_KERNEL
208	MVKL .S1 syscall_trace_entry,A0
209	MVKH .S1 syscall_trace_entry,A0
210	B .S2X A0
211	#else
212	B .S1 syscall_trace_entry
213	#endif
214	ADDKPC .S2 ret_from_syscall_trace,B3,3
215	ADD .S1X 8,SP,A4
216
217	ret_from_syscall_trace:
218	;; tracing returns (possibly new) syscall number
219	MV .D2X A4,B0
220	\|\| MVK .S2 __NR_syscalls,B1
221	CMPLTU .L2 B0,B1,B1
222
223	[!B1] BNOP .S2 ret_from_syscall_function,5
224	\|\| MVK .S1 -ENOSYS,A4
225
226	;; reload syscall args from (possibly modified) stack frame
227	;; and get syscall handler addr from sys_call_table:
228	LDW .D2T2 *+SP(REGS_B4+8),B4
229	\|\| MVKL .S2 sys_call_table,B1
230	LDW .D2T1 *+SP(REGS_A6+8),A6
231	\|\| MVKH .S2 sys_call_table,B1
232	LDW .D2T2 *+B1[B0],B0
233	\|\| MVKL .S2 ret_from_syscall_function,B3
234	LDW .D2T2 *+SP(REGS_B6+8),B6
235	\|\| MVKH .S2 ret_from_syscall_function,B3
236	LDW .D2T1 *+SP(REGS_A8+8),A8
237	LDW .D2T2 *+SP(REGS_B8+8),B8
238	NOP
239	; B0 = sys_call_table[__NR_*]
240	BNOP .S2 B0,5 ; branch to syscall handler
241	\|\| LDW .D2T1 *+SP(REGS_ORIG_A4+8),A4
242
243	syscall_exit_work:
244	AND .D1 _TIF_SYSCALL_TRACE,A2,A0
245	[!A0] BNOP .S1 work_pending,5
246	[A0] B .S2 syscall_trace_exit
247	ADDKPC .S2 resume_userspace,B3,1
248	MVC .S2 CSR,B1
249	SET .S2 B1,0,0,B1
250	MVC .S2 B1,CSR ; enable ints
251
252	work_pending:
253	AND .D1 _TIF_NEED_RESCHED,A2,A0
254	[!A0] BNOP .S1 work_notifysig,5
255
256	work_resched:
257	#ifdef CONFIG_C6X_BIG_KERNEL
258	MVKL .S1 schedule,A1
259	MVKH .S1 schedule,A1
260	B .S2X A1
261	#else
262	B .S2 schedule
263	#endif
264	ADDKPC .S2 work_rescheduled,B3,4
265	work_rescheduled:
266	;; make sure we don't miss an interrupt setting need_resched or
267	;; sigpending between sampling and the rti
268	MASK_INT B2
269	GET_THREAD_INFO A12
270	LDW .D1T1 *+A12(THREAD_INFO_FLAGS),A2
271	MVK .S1 _TIF_WORK_MASK,A1
272	MVK .S1 _TIF_NEED_RESCHED,A3
273	NOP 2
274	AND .D1 A1,A2,A0
275	\|\| AND .S1 A3,A2,A1
276	[!A0] BNOP .S1 restore_all,5
277	[A1] BNOP .S1 work_resched,5
278
279	work_notifysig:
9d34340e MS	280	;; enable interrupts for do_notify_resume()
9d34340e MS	281	UNMASK_INT B2
e94e6682 AJ	282	B .S2 do_notify_resume
	283	LDW .D2T1 *+SP(REGS__END+8),A6 ; syscall flag
	284	ADDKPC .S2 resume_userspace,B3,1
	285	ADD .S1X 8,SP,A4 ; pt_regs pointer is first arg
	286	MV .D2X A2,B4 ; thread_info flags is second arg
	287
	288	;;
	289	;; On C64x+, the return way from exception and interrupt
	290	;; is a little bit different
	291	;;
	292	ENTRY(ret_from_exception)
	293	#ifdef CONFIG_PREEMPT
	294	MASK_INT B2
	295	#endif
	296
	297	ENTRY(ret_from_interrupt)
	298	;;
	299	;; Check if we are comming from user mode.
	300	;;
	301	LDW .D2T2 *+SP(REGS_TSR+8),B0
	302	MVK .S2 0x40,B1
	303	NOP 3
	304	AND .D2 B0,B1,B0
	305	[!B0] BNOP .S2 resume_kernel,5
	306
	307	resume_userspace:
	308	;; make sure we don't miss an interrupt setting need_resched or
	309	;; sigpending between sampling and the rti
	310	MASK_INT B2
	311	GET_THREAD_INFO A12
	312	LDW .D1T1 *+A12(THREAD_INFO_FLAGS),A2
	313	MVK .S1 _TIF_WORK_MASK,A1
	314	MVK .S1 _TIF_NEED_RESCHED,A3
	315	NOP 2
	316	AND .D1 A1,A2,A0
	317	[A0] BNOP .S1 work_pending,5
	318	BNOP .S1 restore_all,5
	319
	320	;;
	321	;; System call handling
	322	;; B0 = syscall number (in sys_call_table)
	323	;; A4,B4,A6,B6,A8,B8 = arguments of the syscall function
	324	;; A4 is the return value register
	325	;;
	326	system_call_saved:
	327	MVK .L2 1,B2
	328	STW .D2T2 B2,*+SP(REGS__END+8) ; set syscall flag
	329	MVC .S2 B2,ECR ; ack the software exception
	330
	331	UNMASK_INT B2 ; re-enable global IT
	332
	333	system_call_saved_noack:
	334	;; Check system call number
	335	MVK .S2 __NR_syscalls,B1
	336	#ifdef CONFIG_C6X_BIG_KERNEL
	337	\|\| MVKL .S1 sys_ni_syscall,A0
	338	#endif
	339	CMPLTU .L2 B0,B1,B1
	340	#ifdef CONFIG_C6X_BIG_KERNEL
	341	\|\| MVKH .S1 sys_ni_syscall,A0
	342	#endif
	343
	344	;; Check for ptrace
	345	GET_THREAD_INFO A12
346
347	#ifdef CONFIG_C6X_BIG_KERNEL
348	[!B1] B .S2X A0
349	#else
350	[!B1] B .S2 sys_ni_syscall
351	#endif
352	[!B1] ADDKPC .S2 ret_from_syscall_function,B3,4
353
354	;; Get syscall handler addr from sys_call_table
355	;; call tracesys_on or call syscall handler
356	LDW .D1T1 *+A12(THREAD_INFO_FLAGS),A2
357	\|\| MVKL .S2 sys_call_table,B1
358	MVKH .S2 sys_call_table,B1
359	LDW .D2T2 *+B1[B0],B0
360	NOP 2
361	; A2 = thread_info flags
362	AND .D1 _TIF_SYSCALL_TRACE,A2,A2
363	[A2] BNOP .S1 tracesys_on,5
364	;; B0 = _sys_call_table[__NR_*]
365	B .S2 B0
366	ADDKPC .S2 ret_from_syscall_function,B3,4
367
368	ret_from_syscall_function:
369	STW .D2T1 A4,*+SP(REGS_A4+8) ; save return value in A4
370	; original A4 is in orig_A4
371	syscall_exit:
372	;; make sure we don't miss an interrupt setting need_resched or
373	;; sigpending between sampling and the rti
374	MASK_INT B2
375	LDW .D1T1 *+A12(THREAD_INFO_FLAGS),A2
376	MVK .S1 _TIF_ALLWORK_MASK,A1
377	NOP 3
378	AND .D1 A1,A2,A2 ; check for work to do
379	[A2] BNOP .S1 syscall_exit_work,5
380
381	restore_all:
382	RESTORE_ALL NRP,NTSR
383
384	;;
385	;; After a fork we jump here directly from resume,
386	;; so that A4 contains the previous task structure.
387	;;
388	ENTRY(ret_from_fork)
389	#ifdef CONFIG_C6X_BIG_KERNEL
390	MVKL .S1 schedule_tail,A0
391	MVKH .S1 schedule_tail,A0
392	B .S2X A0
393	#else
394	B .S2 schedule_tail
395	#endif
396	ADDKPC .S2 ret_from_fork_2,B3,4
397	ret_from_fork_2:
398	;; return 0 in A4 for child process
399	GET_THREAD_INFO A12
400	BNOP .S2 syscall_exit,3
401	MVK .L2 0,B0
402	STW .D2T2 B0,*+SP(REGS_A4+8)
403	ENDPROC(ret_from_fork)
404
46f15067 MS	405	ENTRY(ret_from_kernel_thread)
	406	#ifdef CONFIG_C6X_BIG_KERNEL
	407	MVKL .S1 schedule_tail,A0
	408	MVKH .S1 schedule_tail,A0
	409	B .S2X A0
	410	#else
	411	B .S2 schedule_tail
	412	#endif
	413	LDW .D2T2 +SP(REGS_A0+8),B10 / get fn */
	414	ADDKPC .S2 0f,B3,3
	415	0:
	416	B .S2 B10 /* call fn */
	417	LDW .D2T1 +SP(REGS_A1+8),A4 / get arg */
	418	MVKL .S2 sys_exit,B11
	419	MVKH .S2 sys_exit,B11
	420	ADDKPC .S2 0f,B3,1
	421	0:
	422	BNOP .S2 B11,5 /* jump to sys_exit */
	423	ENDPROC(ret_from_kernel_thread)
	424
39fcf440 MS	425	ENTRY(ret_from_kernel_execve)
	426	GET_THREAD_INFO A12
	427	BNOP .S2 syscall_exit,4
	428	ADD .D2X A4,-8,SP
	429	ENDPROC(ret_from_kernel_execve)
	430
e94e6682 AJ	431	;;
	432	;; These are the interrupt handlers, responsible for calling __do_IRQ()
	433	;; int6 is used for syscalls (see _system_call entry)
	434	;;
	435	.macro SAVE_ALL_INT
	436	SAVE_ALL IRP,ITSR
	437	.endm
	438
	439	.macro CALL_INT int
	440	#ifdef CONFIG_C6X_BIG_KERNEL
	441	MVKL .S1 c6x_do_IRQ,A0
	442	MVKH .S1 c6x_do_IRQ,A0
	443	BNOP .S2X A0,1
	444	MVK .S1 int,A4
	445	ADDAW .D2 SP,2,B4
	446	MVKL .S2 ret_from_interrupt,B3
	447	MVKH .S2 ret_from_interrupt,B3
	448	#else
	449	CALLP .S2 c6x_do_IRQ,B3
	450	\|\| MVK .S1 int,A4
	451	\|\| ADDAW .D2 SP,2,B4
	452	B .S1 ret_from_interrupt
	453	NOP 5
	454	#endif
	455	.endm
	456
	457	ENTRY(_int4_handler)
	458	SAVE_ALL_INT
	459	CALL_INT 4
	460	ENDPROC(_int4_handler)
	461
	462	ENTRY(_int5_handler)
	463	SAVE_ALL_INT
	464	CALL_INT 5
	465	ENDPROC(_int5_handler)
	466
	467	ENTRY(_int6_handler)
	468	SAVE_ALL_INT
	469	CALL_INT 6
	470	ENDPROC(_int6_handler)
	471
	472	ENTRY(_int7_handler)
	473	SAVE_ALL_INT
	474	CALL_INT 7
	475	ENDPROC(_int7_handler)
	476
	477	ENTRY(_int8_handler)
	478	SAVE_ALL_INT
	479	CALL_INT 8
	480	ENDPROC(_int8_handler)
	481
	482	ENTRY(_int9_handler)
	483	SAVE_ALL_INT
	484	CALL_INT 9
	485	ENDPROC(_int9_handler)
	486
	487	ENTRY(_int10_handler)
	488	SAVE_ALL_INT
	489	CALL_INT 10
	490	ENDPROC(_int10_handler)
	491
	492	ENTRY(_int11_handler)
	493	SAVE_ALL_INT
	494	CALL_INT 11
495	ENDPROC(_int11_handler)
496
497	ENTRY(_int12_handler)
498	SAVE_ALL_INT
499	CALL_INT 12
500	ENDPROC(_int12_handler)
501
502	ENTRY(_int13_handler)
503	SAVE_ALL_INT
504	CALL_INT 13
505	ENDPROC(_int13_handler)
506
507	ENTRY(_int14_handler)
508	SAVE_ALL_INT
509	CALL_INT 14
510	ENDPROC(_int14_handler)
511
512	ENTRY(_int15_handler)
513	SAVE_ALL_INT
514	CALL_INT 15
515	ENDPROC(_int15_handler)
516
517	;;
518	;; Handler for uninitialized and spurious interrupts
519	;;
520	ENTRY(_bad_interrupt)
521	B .S2 IRP
522	NOP 5
523	ENDPROC(_bad_interrupt)
524
525	;;
526	;; Entry for NMI/exceptions/syscall
527	;;
528	ENTRY(_nmi_handler)
529	SAVE_ALL NRP,NTSR
530
531	MVC .S2 EFR,B2
532	CMPEQ .L2 1,B2,B2
533	\|\| MVC .S2 TSR,B1
534	CLR .S2 B1,10,10,B1
535	MVC .S2 B1,TSR
536	#ifdef CONFIG_C6X_BIG_KERNEL
537	[!B2] MVKL .S1 process_exception,A0
538	[!B2] MVKH .S1 process_exception,A0
539	[!B2] B .S2X A0
540	#else
541	[!B2] B .S2 process_exception
542	#endif
543	[B2] B .S2 system_call_saved
544	[!B2] ADDAW .D2 SP,2,B1
545	[!B2] MV .D1X B1,A4
546	ADDKPC .S2 ret_from_trap,B3,2
547
548	ret_from_trap:
549	MV .D2X A4,B0
550	[!B0] BNOP .S2 ret_from_exception,5
551
552	#ifdef CONFIG_C6X_BIG_KERNEL
553	MVKL .S2 system_call_saved_noack,B3
554	MVKH .S2 system_call_saved_noack,B3
555	#endif
556	LDW .D2T2 *+SP(REGS_B0+8),B0
557	LDW .D2T1 *+SP(REGS_A4+8),A4
558	LDW .D2T2 *+SP(REGS_B4+8),B4
559	LDW .D2T1 *+SP(REGS_A6+8),A6
560	LDW .D2T2 *+SP(REGS_B6+8),B6
561	LDW .D2T1 *+SP(REGS_A8+8),A8
562	#ifdef CONFIG_C6X_BIG_KERNEL
563	\|\| B .S2 B3
564	#else
565	\|\| B .S2 system_call_saved_noack
566	#endif
567	LDW .D2T2 *+SP(REGS_B8+8),B8
568	NOP 4
569	ENDPROC(_nmi_handler)
570
571	;;
572	;; Jump to schedule() then return to ret_from_isr
573	;;
574	#ifdef CONFIG_PREEMPT
575	resume_kernel:
576	GET_THREAD_INFO A12
577	LDW .D1T1 *+A12(THREAD_INFO_PREEMPT_COUNT),A1
578	NOP 4
579	[A1] BNOP .S2 restore_all,5
580
581	preempt_schedule:
582	GET_THREAD_INFO A2
583	LDW .D1T1 *+A2(THREAD_INFO_FLAGS),A1
584	#ifdef CONFIG_C6X_BIG_KERNEL
585	MVKL .S2 preempt_schedule_irq,B0
586	MVKH .S2 preempt_schedule_irq,B0
587	NOP 2
588	#else
589	NOP 4
590	#endif
591	AND .D1 _TIF_NEED_RESCHED,A1,A1
592	[!A1] BNOP .S2 restore_all,5
593	#ifdef CONFIG_C6X_BIG_KERNEL
594	B .S2 B0
595	#else
596	B .S2 preempt_schedule_irq
597	#endif
598	ADDKPC .S2 preempt_schedule,B3,4
599	#endif /* CONFIG_PREEMPT */
600
601	ENTRY(enable_exception)
602	DINT
603	MVC .S2 TSR,B0
604	MVC .S2 B3,NRP
605	MVK .L2 0xc,B1
606	OR .D2 B0,B1,B0
607	MVC .S2 B0,TSR ; Set GEE and XEN in TSR
608	B .S2 NRP
609	NOP 5
610	ENDPROC(enable_exception)
611
612	ENTRY(sys_sigaltstack)
613	#ifdef CONFIG_C6X_BIG_KERNEL
614	MVKL .S1 do_sigaltstack,A0 ; branch to do_sigaltstack
615	MVKH .S1 do_sigaltstack,A0
616	B .S2X A0
617	#else
618	B .S2 do_sigaltstack
619	#endif
620	LDW .D2T1 *+SP(REGS_SP+8),A6
621	NOP 4
622	ENDPROC(sys_sigaltstack)
623
e94e6682 AJ	624	;;
	625	;; Special system calls
	626	;; return address is in B3
	627	;;
	628	ENTRY(sys_clone)
	629	ADD .D1X SP,8,A4
	630	#ifdef CONFIG_C6X_BIG_KERNEL
	631	\|\| MVKL .S1 sys_c6x_clone,A0
	632	MVKH .S1 sys_c6x_clone,A0
	633	BNOP .S2X A0,5
	634	#else
	635	\|\| B .S2 sys_c6x_clone
	636	NOP 5
	637	#endif
	638	ENDPROC(sys_clone)
	639
	640	ENTRY(sys_rt_sigreturn)
	641	ADD .D1X SP,8,A4
	642	#ifdef CONFIG_C6X_BIG_KERNEL
	643	\|\| MVKL .S1 do_rt_sigreturn,A0
	644	MVKH .S1 do_rt_sigreturn,A0
	645	BNOP .S2X A0,5
	646	#else
	647	\|\| B .S2 do_rt_sigreturn
	648	NOP 5
	649	#endif
	650	ENDPROC(sys_rt_sigreturn)
	651
e94e6682 AJ	652	ENTRY(sys_pread_c6x)
	653	MV .D2X A8,B7
	654	#ifdef CONFIG_C6X_BIG_KERNEL
	655	\|\| MVKL .S1 sys_pread64,A0
	656	MVKH .S1 sys_pread64,A0
	657	BNOP .S2X A0,5
	658	#else
	659	\|\| B .S2 sys_pread64
	660	NOP 5
	661	#endif
	662	ENDPROC(sys_pread_c6x)
	663
	664	ENTRY(sys_pwrite_c6x)
	665	MV .D2X A8,B7
	666	#ifdef CONFIG_C6X_BIG_KERNEL
	667	\|\| MVKL .S1 sys_pwrite64,A0
	668	MVKH .S1 sys_pwrite64,A0
	669	BNOP .S2X A0,5
	670	#else
	671	\|\| B .S2 sys_pwrite64
	672	NOP 5
	673	#endif
	674	ENDPROC(sys_pwrite_c6x)
	675
	676	;; On Entry
	677	;; A4 - path
	678	;; B4 - offset_lo (LE), offset_hi (BE)
	679	;; A6 - offset_lo (BE), offset_hi (LE)
	680	ENTRY(sys_truncate64_c6x)
	681	#ifdef CONFIG_CPU_BIG_ENDIAN
	682	MV .S2 B4,B5
	683	MV .D2X A6,B4
	684	#else
	685	MV .D2X A6,B5
	686	#endif
	687	#ifdef CONFIG_C6X_BIG_KERNEL
	688	\|\| MVKL .S1 sys_truncate64,A0
	689	MVKH .S1 sys_truncate64,A0
	690	BNOP .S2X A0,5
	691	#else
	692	\|\| B .S2 sys_truncate64
	693	NOP 5
	694	#endif
	695	ENDPROC(sys_truncate64_c6x)
	696
	697	;; On Entry
	698	;; A4 - fd
	699	;; B4 - offset_lo (LE), offset_hi (BE)
	700	;; A6 - offset_lo (BE), offset_hi (LE)
	701	ENTRY(sys_ftruncate64_c6x)
	702	#ifdef CONFIG_CPU_BIG_ENDIAN
	703	MV .S2 B4,B5
	704	MV .D2X A6,B4
	705	#else
	706	MV .D2X A6,B5
	707	#endif
	708	#ifdef CONFIG_C6X_BIG_KERNEL
	709	\|\| MVKL .S1 sys_ftruncate64,A0
	710	MVKH .S1 sys_ftruncate64,A0
	711	BNOP .S2X A0,5
	712	#else
	713	\|\| B .S2 sys_ftruncate64
	714	NOP 5
	715	#endif
716	ENDPROC(sys_ftruncate64_c6x)
717
e94e6682 AJ	718	;; On Entry
	719	;; A4 - fd
	720	;; B4 - offset_lo (LE), offset_hi (BE)
	721	;; A6 - offset_lo (BE), offset_hi (LE)
	722	;; B6 - len_lo (LE), len_hi (BE)
	723	;; A8 - len_lo (BE), len_hi (LE)
	724	;; B8 - advice
	725	ENTRY(sys_fadvise64_64_c6x)
	726	#ifdef CONFIG_C6X_BIG_KERNEL
	727	MVKL .S1 sys_fadvise64_64,A0
	728	MVKH .S1 sys_fadvise64_64,A0
	729	BNOP .S2X A0,2
	730	#else
	731	B .S2 sys_fadvise64_64
	732	NOP 2
	733	#endif
	734	#ifdef CONFIG_CPU_BIG_ENDIAN
	735	MV .L2 B4,B5
	736	\|\| MV .D2X A6,B4
	737	MV .L1 A8,A6
	738	\|\| MV .D1X B6,A7
	739	#else
	740	MV .D2X A6,B5
	741	MV .L1 A8,A7
	742	\|\| MV .D1X B6,A6
	743	#endif
	744	MV .L2 B8,B6
	745	ENDPROC(sys_fadvise64_64_c6x)
	746
	747	;; On Entry
	748	;; A4 - fd
	749	;; B4 - mode
	750	;; A6 - offset_hi
	751	;; B6 - offset_lo
	752	;; A8 - len_hi
	753	;; B8 - len_lo
	754	ENTRY(sys_fallocate_c6x)
	755	#ifdef CONFIG_C6X_BIG_KERNEL
	756	MVKL .S1 sys_fallocate,A0
	757	MVKH .S1 sys_fallocate,A0
	758	BNOP .S2X A0,1
	759	#else
	760	B .S2 sys_fallocate
	761	NOP
	762	#endif
	763	MV .D1 A6,A7
	764	MV .D1X B6,A6
	765	MV .D2X A8,B7
	766	MV .D2 B8,B6
	767	ENDPROC(sys_fallocate_c6x)
	768
	769	;; put this in .neardata for faster access when using DSBT mode
	770	.section .neardata,"aw",@progbits
	771	.global current_ksp
	772	.hidden current_ksp
	773	current_ksp:
	774	.word init_thread_union + THREAD_START_SP