| /* 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 |
| |
