/* SPDX-License-Identifier: GPL-2.0 */
/*
 * etrap.S: Sparc trap window preparation for entry into the
 *          Linux kernel.
 *
 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
 */

#include <asm/head.h>
#include <asm/asi.h>
#include <asm/contregs.h>
#include <asm/page.h>
#include <asm/psr.h>
#include <asm/ptrace.h>
#include <asm/winmacro.h>
#include <asm/asmmacro.h>
#include <asm/thread_info.h>

/* Registers to not touch at all. */
#define t_psr        l0 /* Set by caller */
#define t_pc         l1 /* Set by caller */
#define t_npc        l2 /* Set by caller */
#define t_wim        l3 /* Set by caller */
#define t_twinmask   l4 /* Set at beginning of this entry routine. */
#define t_kstack     l5 /* Set right before pt_regs frame is built */
#define t_retpc      l6 /* If you change this, change winmacro.h header file */
#define t_systable   l7 /* Never touch this, could be the syscall table ptr. */
#define curptr       g6 /* Set after pt_regs frame is built */

 .text
 .align 4

 /* SEVEN WINDOW PATCH INSTRUCTIONS */
 .globl tsetup_7win_patch1, tsetup_7win_patch2
 .globl tsetup_7win_patch3, tsetup_7win_patch4
 .globl tsetup_7win_patch5, tsetup_7win_patch6
tsetup_7win_patch1: sll %t_wim, 0x6, %t_wim
tsetup_7win_patch2: and %g2, 0x7f, %g2
tsetup_7win_patch3: and %g2, 0x7f, %g2
tsetup_7win_patch4: and %g1, 0x7f, %g1
tsetup_7win_patch5: sll %t_wim, 0x6, %t_wim
tsetup_7win_patch6: and %g2, 0x7f, %g2
 /* END OF PATCH INSTRUCTIONS */

 /* At trap time, interrupts and all generic traps do the
  * following:
  *
  * rd %psr, %l0
  * b some_handler
  * rd %wim, %l3
  * nop
  *
  * Then 'some_handler' if it needs a trap frame (ie. it has
  * to call c-code and the trap cannot be handled in-window)
  * then it does the SAVE_ALL macro in entry.S which does
  *
  * sethi %hi(trap_setup), %l4
  * jmpl  %l4 + %lo(trap_setup), %l6
  * nop
 */

 /* 2 3 4  window number
  * -----
  * O T S  mnemonic
  *
  * O == Current window before trap
  * T == Window entered when trap occurred
  * S == Window we will need to save if (1<<T) == %wim
  *
  * Before execution gets here, it must be guaranteed that
  * %l0 contains trap time %psr, %l1 and %l2 contain the
  * trap pc and npc, and %l3 contains the trap time %wim.
 */

 .globl trap_setup, tsetup_patch1, tsetup_patch2
 .globl tsetup_patch3, tsetup_patch4
 .globl tsetup_patch5, tsetup_patch6
trap_setup:
 /* Calculate mask of trap window.  See if from user
  * or kernel and branch conditionally.
 */
 mov 1, %t_twinmask
 andcc %t_psr, PSR_PS, %g0   ! fromsupv_p = (psr & PSR_PS)
 be trap_setup_from_user   ! nope, from user mode
  sll %t_twinmask, %t_psr, %t_twinmask ! t_twinmask = (1 << psr)

 /* From kernel, allocate more kernel stack and
  * build a pt_regs trap frame.
 */
 sub %fp, (STACKFRAME_SZ + TRACEREG_SZ), %t_kstack
 STORE_PT_ALL(t_kstack, t_psr, t_pc, t_npc, g2)

 /* See if we are in the trap window. */
 andcc %t_twinmask, %t_wim, %g0
 bne trap_setup_kernel_spill  ! in trap window, clean up
  nop

 /* Trap from kernel with a window available.
  * Just do it...
 */
 jmpl %t_retpc + 0x8, %g0 ! return to caller
  mov %t_kstack, %sp  ! jump onto new stack

trap_setup_kernel_spill:
 ld [%curptr + TI_UWINMASK], %g1
 orcc %g0, %g1, %g0
 bne trap_setup_user_spill ! there are some user windows, yuck
 /* Spill from kernel, but only kernel windows, adjust
  * %wim and go.
 */
  srl %t_wim, 0x1, %g2 ! begin computation of new %wim
tsetup_patch1:
 sll %t_wim, 0x7, %t_wim ! patched on 7 window Sparcs
 or %t_wim, %g2, %g2
tsetup_patch2:
 and %g2, 0xff, %g2  ! patched on 7 window Sparcs

 save %g0, %g0, %g0

 /* Set new %wim value */
 wr %g2, 0x0, %wim

 /* Save the kernel window onto the corresponding stack. */
 STORE_WINDOW(sp)

 restore %g0, %g0, %g0

 jmpl %t_retpc + 0x8, %g0 ! return to caller
  mov %t_kstack, %sp  ! and onto new kernel stack

#define STACK_OFFSET (THREAD_SIZE - TRACEREG_SZ - STACKFRAME_SZ)

trap_setup_from_user:
 /* We can't use %curptr yet. */
 LOAD_CURRENT(t_kstack, t_twinmask)

 sethi %hi(STACK_OFFSET), %t_twinmask
 or %t_twinmask, %lo(STACK_OFFSET), %t_twinmask
 add %t_kstack, %t_twinmask, %t_kstack

 mov 1, %t_twinmask
 sll %t_twinmask, %t_psr, %t_twinmask ! t_twinmask = (1 << psr)

 /* Build pt_regs frame. */
 STORE_PT_ALL(t_kstack, t_psr, t_pc, t_npc, g2)

#if 0
 /* If we're sure every task_struct is THREAD_SIZE aligned,
   we can speed this up. */
 sethi %hi(STACK_OFFSET), %curptr
 or %curptr, %lo(STACK_OFFSET), %curptr
 sub %t_kstack, %curptr, %curptr
#else
 sethi %hi(~(THREAD_SIZE - 1)), %curptr
 and %t_kstack, %curptr, %curptr
#endif

 /* Clear current_thread_info->w_saved */
 st %g0, [%curptr + TI_W_SAVED]

 /* See if we are in the trap window. */
 andcc %t_twinmask, %t_wim, %g0
 bne trap_setup_user_spill  ! yep we are
  orn %g0, %t_twinmask, %g1  ! negate trap win mask into %g1

 /* Trap from user, but not into the invalid window.
  * Calculate new umask.  The way this works is,
  * any window from the %wim at trap time until
  * the window right before the one we are in now,
  * is a user window.  A diagram:
  *
  *      7 6 5 4 3 2 1 0    window number
  *      ---------------
  *        I     L T        mnemonic
  *
  * Window 'I' is the invalid window in our example,
  * window 'L' is the window the user was in when
  * the trap occurred, window T is the trap window
  * we are in now.  So therefore, windows 5, 4 and
  * 3 are user windows.  The following sequence
  * computes the user winmask to represent this.
 */
 subcc %t_wim, %t_twinmask, %g2
 bneg,a 1f
  sub %g2, 0x1, %g2
1:
 andn %g2, %t_twinmask, %g2
tsetup_patch3:
 and %g2, 0xff, %g2   ! patched on 7win Sparcs
 st %g2, [%curptr + TI_UWINMASK] ! store new umask

 jmpl %t_retpc + 0x8, %g0  ! return to caller
  mov %t_kstack, %sp   ! and onto kernel stack

trap_setup_user_spill:
 /* A spill occurred from either kernel or user mode
  * and there exist some user windows to deal with.
  * A mask of the currently valid user windows
  * is in %g1 upon entry to here.
 */

tsetup_patch4:
 and %g1, 0xff, %g1  ! patched on 7win Sparcs, mask
 srl %t_wim, 0x1, %g2 ! compute new %wim
tsetup_patch5:
 sll %t_wim, 0x7, %t_wim ! patched on 7win Sparcs
 or %t_wim, %g2, %g2 ! %g2 is new %wim
tsetup_patch6:
 and %g2, 0xff, %g2  ! patched on 7win Sparcs
 andn %g1, %g2, %g1  ! clear this bit in %g1
 st %g1, [%curptr + TI_UWINMASK]

 save %g0, %g0, %g0

 wr %g2, 0x0, %wim

 /* Call MMU-architecture dependent stack checking
  * routine.
 */
 b tsetup_srmmu_stackchk
  andcc %sp, 0x7, %g0

 /* Architecture specific stack checking routines.  When either
  * of these routines are called, the globals are free to use
  * as they have been safely stashed on the new kernel stack
  * pointer.  Thus the definition below for simplicity.
 */
#define glob_tmp     g1

 .globl tsetup_srmmu_stackchk
tsetup_srmmu_stackchk:
 /* Check results of callers andcc %sp, 0x7, %g0 */
 bne trap_setup_user_stack_is_bolixed
  sethi   %hi(PAGE_OFFSET), %glob_tmp

 cmp %glob_tmp, %sp
 bleu,a 1f
LEON_PI( lda [%g0] ASI_LEON_MMUREGS, %glob_tmp) ! read MMU control
SUN_PI_( lda [%g0] ASI_M_MMUREGS, %glob_tmp)  ! read MMU control

trap_setup_user_stack_is_bolixed:
 /* From user/kernel into invalid window w/bad user
  * stack. Save bad user stack, and return to caller.
 */
 SAVE_BOLIXED_USER_STACK(curptr, g3)
 restore %g0, %g0, %g0

 jmpl %t_retpc + 0x8, %g0
  mov %t_kstack, %sp

1:
 /* Clear the fault status and turn on the no_fault bit. */
 or %glob_tmp, 0x2, %glob_tmp  ! or in no_fault bit
LEON_PI(sta %glob_tmp, [%g0] ASI_LEON_MMUREGS)  ! set it
SUN_PI_(sta %glob_tmp, [%g0] ASI_M_MMUREGS)  ! set it

 /* Dump the registers and cross fingers. */
 STORE_WINDOW(sp)

 /* Clear the no_fault bit and check the status. */
 andn %glob_tmp, 0x2, %glob_tmp
LEON_PI(sta %glob_tmp, [%g0] ASI_LEON_MMUREGS)
SUN_PI_(sta %glob_tmp, [%g0] ASI_M_MMUREGS)

 mov AC_M_SFAR, %glob_tmp
LEON_PI(lda [%glob_tmp] ASI_LEON_MMUREGS, %g0)
SUN_PI_(lda [%glob_tmp] ASI_M_MMUREGS, %g0)

 mov AC_M_SFSR, %glob_tmp
LEON_PI(lda [%glob_tmp] ASI_LEON_MMUREGS, %glob_tmp)! save away status of winstore
SUN_PI_(lda [%glob_tmp] ASI_M_MMUREGS, %glob_tmp) ! save away status of winstore

 andcc %glob_tmp, 0x2, %g0   ! did we fault?
 bne trap_setup_user_stack_is_bolixed ! failure
  nop

 restore %g0, %g0, %g0

 jmpl %t_retpc + 0x8, %g0
  mov %t_kstack, %sp