Subversion Repositories or1k

/*
 * Low level exception handling
 *
 * 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) 1994, 1995 by Ralf Baechle
 */

/*
 * entry.S contains the system-call and fault low-level handling routines.
 * This also contains the timer-interrupt handler, as well as all interrupts
 * and faults that can result in a task-switch. The ISA dependent TLB
 * code is in arch/mips/kernel/<cputype>.S
 */
#include <linux/sys.h>

#include <asm/asm.h>
#include <asm/errno.h>
#include <asm/segment.h>
#include <asm/mipsregs.h>
#include <asm/mipsconfig.h>
#include <asm/page.h>
#include <asm/pgtable.h>
#include <asm/stackframe.h>
#include <asm/processor.h>
#include <asm/unistd.h>

/*
 * These are offsets into the task-struct.
 */
state           =  0
counter         =  4
priority        =  8
signal          = 12
blocked         = 16
flags           = 20
errno           = 24
exec_domain     = 60

#ifdef __SMP__
#error "Fix this for SMP"
#else
#define current current_set
#endif

/*
 * Heia ...  The %lo, %hi and %HI stuff is too strong for the ELF assembler
 * and the ABI to cope with ...
 */
                .text
                .set    noreorder
                .align 4
handle_bottom_half:
                lui     s0,%hi(intr_count)
                lw      s1,%lo(intr_count)(s0)
                mfc0    s3,CP0_STATUS           # Enable IRQs
                addiu   s2,s1,1
                sw      s2,%lo(intr_count)(s0)
                ori     t0,s3,0x1f
                xori    t0,0x1e
                jal     do_bottom_half
                mtc0    t0,CP0_STATUS           # delay slot
                mtc0    s3,CP0_STATUS           # Restore old IRQ state
                b       9f
                sw      s1,%lo(intr_count)(s0)  # delay slot

reschedule:     jal     schedule 
                nop                             # delay slot
EXPORT(ret_from_sys_call)
                lw      t0,intr_count           # bottom half
                bnez    t0,return

9:              lw      t0,bh_mask              # delay slot
                lw      t1,bh_active            # unused delay slot
                and     t0,t1
                bnez    t0,handle_bottom_half

                lw      t0,FR_STATUS(sp)        # returning to kernel mode?
                andi    t1,t0,0x10
                beqz    t1,return               # -> yes

                mfc0    t0,CP0_STATUS           # delay slot
                lw      t1,need_resched
                ori     t0,0x1f                 # enable irqs
                xori    t0,0x1e
                bnez    t1,reschedule
                mtc0    t0,CP0_STATUS           # delay slot

                lw      s0,current
                lw      t0,task
                lw      a0,blocked(s0)
                beq     s0,t0,return            # task[0] cannot have signals
                                                # save blocked in a0 for
                                                # signal handling
                lw      t0,signal(s0)
                nor     t1,zero,a0
                and     t1,t0,t1
                beqz    t1,return
                nop

                jal     do_signal
                move    a1,sp                   # delay slot
                
                .set    noat
EXPORT(return)  RESTORE_ALL
                ERET
                .set    at

/*
 * Beware: interrupt, fast_interrupt and bad_interrupt have unusual
 * calling conventions to speedup the mess.
 *
 * t1 - interrupt number
 * s2 - destroyed
 * return values:
 * v0 - return routine
 */
                .text
                .set    at
                .align  5
NESTED(interrupt, FR_SIZE, sp)
                move    s2,ra
                mfc0    t0,CP0_STATUS                   # enable IRQs
                ori     t0,0x1f
                xori    t0,0x1e
                mtc0    t0,CP0_STATUS
                move    a0,t1
                jal     do_IRQ
                move    a1,sp                           # delay slot
                mfc0    t0,CP0_STATUS                   # disable IRQs
                ori     t0,1
                xori    t0,1
                la      v0,ret_from_sys_call
                jr      s2
                mtc0    t0,CP0_STATUS                   # delay slot
                END(interrupt)

                .align  5
NESTED(fast_interrupt, FR_SIZE, sp)
                move    s2,ra
                move    a0,t1
                jal     do_fast_IRQ
                move    a1,sp                           # delay slot
                lui     v0,%hi(return)
                jr      s2
                addiu   v0,%lo(return)                  # delay slot
                END(fast_interrupt)

LEAF(bad_interrupt)
                /*
                 * Don't return & unblock the pic
                 */
                j       return
                nop
                END(bad_interrupt)

/*
 * do_syscall calls the function in a1 with upto 7 arguments.  If over
 * four arguments are being requested, the additional arguments will
 * be copied from the user stack pointed to by a0->reg29.
 * Note that this routine relies on the GNU assemblers weak instruction
 * scheduling abilities to generate the best possible code for all MIPS CPUs.
 *
 * a0 (struct pt_regs *)  pointer to user registers
 * a1 (syscall_t)         pointer to syscall to do
 * a2 (int)               number of arguments to syscall
 */
                .set    noreorder
                .text
NESTED(do_syscalls, 32, sp)
                subu    sp,32
                sw      ra,28(sp)
                sll     a2,a2,PTRLOG
                lw      t0,dst(a2)
                move    t2,a1
                jalr    t0
                lw      t0,FR_REG29(a0)         # get old user stack pointer

                .set    reorder                 # for sake of R3000
7:              lw      t1,24(t0)               # parameter #7 from usp
                sw      t1,24(t0)
6:              lw      t1,20(t0)               # parameter #6 from usp
                sw      t1,20(t0)
5:              lw      t1,16(t0)               # parameter #5 from usp
                sw      t1,16(t0)
                .set    noreorder
4:              lw      a3,FR_REG7(a0)          # 4 args
3:              lw      a2,FR_REG6(a0)          # 3 args
2:              lw      a1,FR_REG5(a0)          # 2 args
1:              jalr    t2                      # 1 args
                lw      a0,FR_REG4(a0)          # delay slot
                .set    reorder
                lw      ra,28(sp)
                addiu   sp,32
                jr      ra
0:              jalr    t2                      # 0 args, just pass a0
                lw      ra,28(sp)
                addiu   sp,32
                jr      ra
                END(do_syscalls)
                .set    noreorder

                .rdata
                .align  PTRLOG
dst:            PTR     0b, 1b, 2b, 3b, 4b, 5b, 6b, 7b

/*
 * Build a default exception handler for the exceptions that don't need
 * special handlers.  If you didn't know yet - I *like* playing games with
 * the C preprocessor ...
 */
#define __BUILD_silent(exception)
#define __BUILD_verbose(exception)                                      \
                la      a1,8f;                                          \
                TEXT    (#exception);                                   \
                lw      a2,FR_EPC(sp);                                  \
                PRINT("Got %s at %08x.\n")
#define __BUILD_count(exception)                                        \
                .set    reorder;                                        \
                lw      t0,exception_count_##exception;                 \
                addiu   t0,1;                                           \
                sw      t0,exception_count_##exception;                 \
                .set    noreorder;                                      \
                .data;                                                  \
EXPORT(exception_count_##exception);                                    \
                .word   0;                                              \
                .text;
#define BUILD_HANDLER(exception,verbose)                                \
                .text;                                                  \
                .align  5;                                              \
                NESTED(handle_##exception, FR_SIZE, sp);                \
                .set    noat;                                           \
                SAVE_ALL;                                               \
                STI;                                                    \
                .set    at;                                             \
                __BUILD_##verbose(exception);                           \
                li      t0,-1;                   /* not a sys call */   \
                sw      t0,FR_ORIG_REG2(sp);                            \
                jal     do_##exception;                                 \
                move    a0,sp;                   /* delay slot */       \
                j       ret_from_sys_call;                              \
                nop;                             /* delay slot */       \
                END(handle_##exception)

                BUILD_HANDLER(adel,verbose)             /* #4  */
                BUILD_HANDLER(ades,verbose)             /* #5  */
                BUILD_HANDLER(ibe,verbose)              /* #6  */
                BUILD_HANDLER(dbe,verbose)              /* #7  */
                BUILD_HANDLER(sys,silent)               /* #8  */
                BUILD_HANDLER(bp,verbose)               /* #9  */
                BUILD_HANDLER(ri,verbose)               /* #10 */
                BUILD_HANDLER(cpu,silent)               /* #11 */
                BUILD_HANDLER(ov,verbose)               /* #12 */
                BUILD_HANDLER(tr,verbose)               /* #13 */
                BUILD_HANDLER(vcei,verbose)             /* #14 */
                BUILD_HANDLER(fpe,verbose)              /* #15 */
                BUILD_HANDLER(watch,verbose)            /* #23 */
                BUILD_HANDLER(vced,verbose)             /* #31 */
                BUILD_HANDLER(reserved,verbose)         /* others */

/*
 * Exception handler table with 32 entries.
 * This might be extended to handle software exceptions
 */
                .bss
                .align  PTRLOG
EXPORT(exception_handlers)
                .fill   32,PTRSIZE,0

/*
 * Interrupt handler table with 16 entries.
 */
EXPORT(IRQ_vectors)
                .fill   16,PTRSIZE,0

/*
 * Table of syscalls
 */
                .data
                .align  PTRLOG
EXPORT(sys_call_table)
                /*
                 * Reserved space for all the SVR4, SVR, BSD43 and POSIX
                 * flavoured syscalls.
                 */
                .space  (__NR_Linux)*PTRSIZE

                /*
                 * Linux flavoured syscalls.
                 */
#define SYS(call, narg) PTR call
#include "syscalls.h"

/*
 * Number of arguments of each syscall
 */
EXPORT(sys_narg_table)
                /*
                 * Reserved space for all the SVR4, SVR, BSD43 and POSIX
                 * flavoured syscalls.
                 */
                .space  (__NR_Linux)

                /*
                 * Linux flavoured syscalls.
                 */
#undef SYS
#define SYS(call, narg) .byte narg
#include "syscalls.h"