/*
 * 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) 1995 - 2000, 2001 by Ralf Baechle
 * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
 * Copyright (C) 2001 MIPS Technologies, Inc.
 * Copyright (C) 2004 Thiemo Seufer
 *
 * Hairy, the userspace application uses a different argument passing
 * convention than the kernel, so we have to translate things from o32
 * to ABI64 calling convention.  64-bit syscalls are also processed
 * here for now.
 */
#include <linux/errno.h>
#include <asm/asm.h>
#include <asm/asmmacro.h>
#include <asm/irqflags.h>
#include <asm/mipsregs.h>
#include <asm/regdef.h>
#include <asm/stackframe.h>
#include <asm/thread_info.h>
#include <asm/unistd.h>
#include <asm/sysmips.h>

 .align 5
NESTED(handle_sys, PT_SIZE, sp)
 .set noat
 SAVE_SOME
 TRACE_IRQS_ON_RELOAD
 STI
 .set at
 ld t1, PT_EPC(sp)  # skip syscall on return

 dsubu t0, v0, __NR_O32_Linux # check syscall number
 sltiu t0, t0, __NR_O32_Linux_syscalls
 daddiu t1, 4   # skip to next instruction
 sd t1, PT_EPC(sp)
 beqz t0, not_o32_scall
#if 0
 SAVE_ALL
 move a1, v0
 ASM_PRINT("Scall %ld\n")
 RESTORE_ALL
#endif

 /* We don't want to stumble over broken sign extensions from
   userland. O32 does never use the upper half. */
 sll a0, a0, 0
 sll a1, a1, 0
 sll a2, a2, 0
 sll a3, a3, 0

 sd a3, PT_R26(sp)  # save a3 for syscall restarting

 /*
  * More than four arguments.  Try to deal with it by copying the
  * stack arguments from the user stack to the kernel stack.
  * This Sucks (TM).
  *
  * We intentionally keep the kernel stack a little below the top of
  * userspace so we don't have to do a slower byte accurate check here.
 */
 ld t0, PT_R29(sp)  # get old user stack pointer
 daddu t1, t0, 32
 bltz t1, bad_stack

load_a4: lw a4, 16(t0)  # argument #5 from usp
load_a5: lw a5, 20(t0)  # argument #6 from usp
load_a6: lw a6, 24(t0)  # argument #7 from usp
load_a7: lw a7, 28(t0)  # argument #8 from usp
loads_done:

 .section __ex_table,"a"
 PTR_WD load_a4, bad_stack_a4
 PTR_WD load_a5, bad_stack_a5
 PTR_WD load_a6, bad_stack_a6
 PTR_WD load_a7, bad_stack_a7
 .previous

 /*
  * absolute syscall number is in v0 unless we called syscall(__NR_###)
  * where the real syscall number is in a0
  * note: NR_syscall is the first O32 syscall but the macro is
  * only defined when compiling with -mabi=32 (CONFIG_32BIT)
  * therefore __NR_O32_Linux is used (4000)
 */

 subu t2, v0,  __NR_O32_Linux
 bnez t2, 1f /* __NR_syscall at offset 0 */
 LONG_S a0, TI_SYSCALL($28) # Save a0 as syscall number
 b 2f
1:
 LONG_S v0, TI_SYSCALL($28) # Save v0 as syscall number
2:

 li t1, _TIF_WORK_SYSCALL_ENTRY
 LONG_L t0, TI_FLAGS($28) # syscall tracing enabled?
 and t0, t1, t0
 bnez t0, trace_a_syscall

syscall_common:
 dsll t0, v0, 3  # offset into table
 ld t2, (sys32_call_table - (__NR_O32_Linux * 8))(t0)

 jalr t2   # Do The Real Thing (TM)

 li t0, -EMAXERRNO - 1 # error?
 sltu t0, t0, v0
 sd t0, PT_R7(sp)  # set error flag
 beqz t0, 1f

 ld t1, PT_R2(sp)  # syscall number
 dnegu v0   # error
 sd t1, PT_R0(sp)  # save it for syscall restarting
1: sd v0, PT_R2(sp)  # result

o32_syscall_exit:
 j syscall_exit_partial

/* ------------------------------------------------------------------------ */

trace_a_syscall:
 SAVE_STATIC
 sd a4, PT_R8(sp)  # Save argument registers
 sd a5, PT_R9(sp)
 sd a6, PT_R10(sp)
 sd a7, PT_R11(sp)  # For indirect syscalls

 move a0, sp
 jal syscall_trace_enter

 bltz v0, 1f   # seccomp failed? Skip syscall

 RESTORE_STATIC
 ld v0, PT_R2(sp)  # Restore syscall (maybe modified)
 ld a0, PT_R4(sp)  # Restore argument registers
 ld a1, PT_R5(sp)
 ld a2, PT_R6(sp)
 ld a3, PT_R7(sp)
 ld a4, PT_R8(sp)
 ld a5, PT_R9(sp)
 ld a6, PT_R10(sp)
 ld a7, PT_R11(sp)  # For indirect syscalls

 dsubu t0, v0, __NR_O32_Linux # check (new) syscall number
 sltiu t0, t0, __NR_O32_Linux_syscalls
 beqz t0, not_o32_scall

 j syscall_common

1: j syscall_exit

/* ------------------------------------------------------------------------ */

 /*
  * The stackpointer for a call with more than 4 arguments is bad.
 */
bad_stack:
 li v0, EFAULT
 sd v0, PT_R2(sp)
 li t0, 1   # set error flag
 sd t0, PT_R7(sp)
 j o32_syscall_exit

bad_stack_a4:
 li a4, 0
 b load_a5

bad_stack_a5:
 li a5, 0
 b load_a6

bad_stack_a6:
 li a6, 0
 b load_a7

bad_stack_a7:
 li a7, 0
 b loads_done

not_o32_scall:
 /*
  * This is not an o32 compatibility syscall, pass it on
  * to the 64-bit syscall handlers.
 */
#ifdef CONFIG_MIPS32_N32
 j handle_sysn32
#else
 j handle_sys64
#endif
 END(handle_sys)

LEAF(sys32_syscall)
 subu t0, a0, __NR_O32_Linux # check syscall number
 sltiu v0, t0, __NR_O32_Linux_syscalls
 beqz t0, einval  # do not recurse
 dsll t1, t0, 3
 beqz v0, einval
 ld t2, sys32_call_table(t1)  # syscall routine

 move a0, a1   # shift argument registers
 move a1, a2
 move a2, a3
 move a3, a4
 move a4, a5
 move a5, a6
 move a6, a7
 jr t2
 /* Unreached */

einval: li v0, -ENOSYS
 jr ra
 END(sys32_syscall)

#define __SYSCALL_WITH_COMPAT(nr, native, compat) __SYSCALL(nr, compat)
#define __SYSCALL(nr, entry) PTR_WD entry
 .align 3
 .type sys32_call_table,@object
EXPORT(sys32_call_table)
#include <asm/syscall_table_o32.h>