#if defined(JAZZ) && defined(R4000)
/*++
Copyright (c) 1990 Microsoft Corporation
Module Name:
fw4trap.s
Abstract:
This module contains the fw exception handling functions.
Author:
Lluis Abello (lluis) 4-Sep-91
--*/
//
// include header file
//
#include <ksmips.h>
#include <selfmap.h>
.data
//
// Declare the table where to store the processor registers.
// also align it so that we can store doubles.
//
.align 4
ALTERNATE_ENTRY(RegisterTable)
.space RegisterTableSize
ALTERNATE_ENTRY(EndRegisterTable)
.text
.set noat
.set noreorder
SBTTL("User TLB dispatcher")
/*++
Routine Description:
This routine gets control on a User TLB Miss exception.
It reads the TLB Miss handler address from the System
Parameter Block and jumps to it.
Arguments:
None.
Return Value:
None.
--*/
LEAF_ENTRY(FwTbMissStartAddress)
li k0,KSEG0_BASE
lw k0,0x1018(k0)// Load address of UTLB handler
nop
jal k1,k0 // jump to handler saving return
nop // address in k1
mtc0 k0,epc // Handler returns return address in K0
nop // 2 cycle hazard
nop //
eret // restore from exception
nop
ALTERNATE_ENTRY(FwTbMissEndAddress)
.end FwTbMissStartAddress
SBTTL("General Exception dispatcher")
/*++
Routine Description:
This routine gets control on a General exception.
It reads the General exception handler address from the System
Parameter Block and jumps to it.
Arguments:
None.
Return Value:
None.
--*/
LEAF_ENTRY(FwGeneralExceptionStartAddress)
li k0,KSEG0_BASE
lw k0,0x1014(k0)// Load address of GE handler
nop
jal k1,k0 // jump to handler saving return
nop // address in k1
mtc0 k0,epc // Handler returns return address in K0
nop // 2 cycle hazard
nop //
eret // restore from exception
nop
ALTERNATE_ENTRY(FwGeneralExceptionEndAddress)
.end FwGeneralExceptionStartAddress
SBTTL("CacheError Exception dispatcher")
/*++
Routine Description:
This routine gets control on a cache error exception.
It jumps to the Monitor exception handler.
It gets copied to address 0xA0000100
Arguments:
None.
Return Value:
None.
--*/
LEAF_ENTRY(FwCacheErrorExceptionStartAddress)
la k0,CacheExceptionMonitorEntry // load address of Monitor entry
li k1,KSEG1_BASE // convert address to non cached
or k0,k0,k1 //
j k0
nop
ALTERNATE_ENTRY(FwCacheErrorExceptionEndAddress)
.end FwCacheErrorExceptionStartAddress
SBTTL("Firmware Exception intialize")
/*++
Routine Description:
This routine copies the User TLB dispatcher and
the General Exception dispatcher to the R4000 vector
addresses.
Arguments:
None.
Return Value:
None.
--*/
//
// Copy the TB miss and general exception dispatchers to low memory.
//
NESTED_ENTRY(FwExceptionInitialize,4, zero)
subu sp,sp,4 // decrement stack pointer
sw ra,0(sp) // save ra
la t2,FwTbMissStartAddress // get user TB miss start address
la t3,FwTbMissEndAddress // get user TB miss end address
li t4,KSEG1_BASE // get copy address
10: lw t5,0(t2) // copy code to low memory
addu t2,t2,4 // advance copy pointers
sw t5,0(t4) //
bne t2,t3,10b // if ne, more to copy
addu t4,t4,4 //
la t2,FwGeneralExceptionStartAddress // get general exception start address
la t3,FwGeneralExceptionEndAddress // get general exception end address
li t4,KSEG1_BASE + 0x180 // get copy address
20: lw t5,0(t2) // copy code to low memory
addu t2,t2,4 // advance copy pointers
sw t5,0(t4) //
bne t2,t3,20b // if ne, more to copy
addu t4,t4,4 //
la t2,FwCacheErrorExceptionStartAddress // get cache error exception start address
la t3,FwCacheErrorExceptionEndAddress // get cache error exception end address
li t4,KSEG1_BASE + 0x100 // get copy address
30: lw t5,0(t2) // copy code to low memory
addu t2,t2,4 // advance copy pointers
sw t5,0(t4) //
bne t2,t3,30b // if ne, more to copy
addu t4,t4,4 //
//
// Set the Monitor exception handler address in the vector.
//
li t0,KSEG0_BASE
la t1,FwExceptionHandler
sw t1,0x1014(t0) // Init GE vector
sw t1,0x1018(t0) // Init UTLB vector
jal HalSweepIcache // sweep the instruction cache
nop
jal HalSweepDcache // sweep the data cache
nop
//
// Clear the BEV in the psr and enable IO device interrupts
//
li t0,(1<<PSR_CU1) | (1 << PSR_IE) | (1<< (PSR_INTMASK+3))
mtc0 t0,psr // set new psr.
nop //
nop //
nop //
lw ra,0(sp) // load return address
addiu sp,sp,4 // restore stack pointer
j ra // return to caller
nop
.end FwExceptionInitialize
SBTTL("Monitor Exception Handler")
/*++
Routine Description:
This routine implements the exception handler for
the monitor.
Arguments:
k1 specifies the caller source in the following way:
- If k1 contains a word aligned address. The exception is
either a UTLB or a GE. The cause register supplies the cause
of the exception.
- Otherwise k1 contains a value that identifies the caller.
None.
Return Value:
None.
--*/
LEAF_ENTRY(FwExceptionHandler)
mfc0 k0,cause // read cause register
nop
andi k0,k0,R4000_XCODE_MASK // isolate cause of exception
bne k0,zero,10f // if not interrupt go to Monitor
nop
subu sp,sp,FwFrameSize // decrement state pointer
sw k1,FwFrameK1(sp) // save volatile state
sw ra,FwFrameRa(sp) // save volatile state
sw a0,FwFrameA0(sp) // save volatile state
sw a1,FwFrameA1(sp) // save volatile state
sw a2,FwFrameA2(sp) // save volatile state
sw a3,FwFrameA3(sp) // save volatile state
sw v0,FwFrameV0(sp) // save volatile state
sw v1,FwFrameV1(sp) // save volatile state
sw t0,FwFrameT0(sp) // save volatile state
sw t1,FwFrameT1(sp) // save volatile state
sw t2,FwFrameT2(sp) // save volatile state
sw t3,FwFrameT3(sp) // save volatile state
sw t4,FwFrameT4(sp) // save volatile state
sw t5,FwFrameT5(sp) // save volatile state
sw t6,FwFrameT6(sp) // save volatile state
sw t7,FwFrameT7(sp) // save volatile state
sw t8,FwFrameT8(sp) // save volatile state
sw t9,FwFrameT9(sp) // save volatile state
mfc0 a0,cause // read cause register
mfc0 a1,psr // read psr.
sw AT,FwFrameAT(sp) // save volatile state
jal FwInterruptHandler // call c routine
and a0,a0,a1 // mask IM to clear disabled interrupts.
move k0,v0 // save return value in k0
lw k1,FwFrameK1(sp) // restore volatile state
lw ra,FwFrameRa(sp) // restore volatile state
lw a0,FwFrameA0(sp) // restore volatile state
lw a1,FwFrameA1(sp) // restore volatile state
lw a2,FwFrameA2(sp) // restore volatile state
lw a3,FwFrameA3(sp) // restore volatile state
lw v0,FwFrameV0(sp) // restore volatile state
lw v1,FwFrameV1(sp) // restore volatile state
lw t0,FwFrameT0(sp) // restore volatile state
lw t1,FwFrameT1(sp) // restore volatile state
lw t2,FwFrameT2(sp) // restore volatile state
lw t3,FwFrameT3(sp) // restore volatile state
lw t4,FwFrameT4(sp) // restore volatile state
lw t5,FwFrameT5(sp) // restore volatile state
lw t6,FwFrameT6(sp) // restore volatile state
lw t7,FwFrameT7(sp) // restore volatile state
lw t8,FwFrameT8(sp) // restore volatile state
lw t9,FwFrameT9(sp) // restore volatile state
lw AT,FwFrameAT(sp) // save volatile state
beq k0,zero,10f // if routine returned false do not return
addiu sp,sp,FwFrameSize // restore stack pointer
mfc0 k0,epc // get return address
nop
j k1 // return to caller
nop //
//
// Control reaches here if an exception other than an interrupt occurred
// or if the interrupt handler returned false meaning that it didn't
// know how to handle the interrupt exception.
//
// At this time no state has been destroyed and register k1 still contains
// the address where to return.
//
10:
addiu k0,k0,-XCODE_BREAKPOINT // substract breakpoint code
beq k0,zero,10f // if eq Bp exception, call KD unconditionally
la k0,KdInstalled // load address of boolean
lbu k0,0(k0) // read boolean
beq k0,zero,MonitorExceptionHandler // if false go to the monitor
nop // otherwise
10: j KiGeneralException // go to the debugger.
nop
//
// This is the entry point when the monitor is called.
// Set k1 to 3 to tell the Monitor than can execute a j ra
// to quit.
//
ALTERNATE_ENTRY(FwMonitor)
b MonitorExceptionHandler
li k1,3 // set k1 to 3 to indicate we don't get
nop // here because of an exception
// The monitor returns to ra which points
// to where we got called from.
ALTERNATE_ENTRY(CacheExceptionMonitorEntry)
la k0,RegisterTable // get address of table.
or k0,k0,k1 // set it non cached.
b MonitorEntry // go to monitor
ori k1,zero,CACHE_EXCEPTION // set flag to tell that parity error occurred
ALTERNATE_ENTRY(MonitorExceptionHandler)
//
// Save the registers.
//
la k0,RegisterTable // get address of table.
ALTERNATE_ENTRY(MonitorEntry)
sw zero,zeroRegTable(k0)
sw AT,atRegTable(k0)
sw v0,v0RegTable(k0)
sw v1,v1RegTable(k0)
sw a0,a0RegTable(k0)
sw a1,a1RegTable(k0)
sw a2,a2RegTable(k0)
sw a3,a3RegTable(k0)
sw t0,t0RegTable(k0)
sw t1,t1RegTable(k0)
sw t2,t2RegTable(k0)
sw t3,t3RegTable(k0)
sw t4,t4RegTable(k0)
sw t5,t5RegTable(k0)
sw t6,t6RegTable(k0)
sw t7,t7RegTable(k0)
sw s0,s0RegTable(k0)
sw s1,s1RegTable(k0)
sw s2,s2RegTable(k0)
sw s3,s3RegTable(k0)
sw s4,s4RegTable(k0)
sw s5,s5RegTable(k0)
sw s6,s6RegTable(k0)
sw s7,s7RegTable(k0)
sw t8,t8RegTable(k0)
sw t9,t9RegTable(k0)
sw k0,k0RegTable(k0)
sw k1,k1RegTable(k0)
sw gp,gpRegTable(k0)
sw sp,spRegTable(k0)
sw s8,s8RegTable(k0)
sw ra,raRegTable(k0)
//
// Store coprocessor1 registers.
//
cfc1 v0,fsr
sdc1 f0,f0RegTable(k0)
sdc1 f2,f2RegTable(k0)
sdc1 f4,f4RegTable(k0)
sdc1 f6,f6RegTable(k0)
sdc1 f8,f8RegTable(k0)
sdc1 f10,f10RegTable(k0)
sdc1 f12,f12RegTable(k0)
sdc1 f14,f14RegTable(k0)
sdc1 f16,f16RegTable(k0)
sdc1 f18,f18RegTable(k0)
sdc1 f20,f20RegTable(k0)
sdc1 f22,f22RegTable(k0)
sdc1 f24,f24RegTable(k0)
sdc1 f26,f26RegTable(k0)
sdc1 f28,f28RegTable(k0)
sdc1 f30,f30RegTable(k0)
sw v0,fsrRegTable(k0)
//
// Store cop0 registers.
//
mfc0 v1,index
mfc0 v0,random
sw v1,indexRegTable(k0)
sw v0,randomRegTable(k0)
mfc0 v1,entrylo0
nop
mfc0 v0,entrylo1
sw v1,entrylo0RegTable(k0)
sw v0,entrylo1RegTable(k0)
mfc0 v1,context
mfc0 v0,pagemask
sw v1,contextRegTable(k0)
sw v0,pagemaskRegTable(k0)
mfc0 v1,wired
mfc0 v0,badvaddr
sw v1,wiredRegTable(k0)
sw v0,badvaddrRegTable(k0)
mfc0 v1,count
mfc0 v0,entryhi
sw v1,countRegTable(k0)
sw v0,entryhiRegTable(k0)
mfc0 v1,compare
mfc0 v0,psr
sw v1,compareRegTable(k0)
sw v0,psrRegTable(k0)
mfc0 v1,cause
mfc0 v0,epc
sw v1,causeRegTable(k0)
sw v0,epcRegTable(k0)
mfc0 v1,prid
mfc0 v0,config
sw v1,pridRegTable(k0)
sw v0,configRegTable(k0)
mfc0 v1,lladdr
mfc0 v0,watchlo
sw v1,lladdrRegTable(k0)
sw v0,watchloRegTable(k0)
mfc0 v1,watchhi
mfc0 v0,ecc
sw v1,watchhiRegTable(k0)
sw v0,eccRegTable(k0)
mfc0 v1,cacheerr
mfc0 v0,taglo
sw v1,cacheerrorRegTable(k0)
sw v0,tagloRegTable(k0)
mfc0 v1,taghi
mfc0 v0,errorepc
sw v1,taghiRegTable(k0)
sw v0,errorepcRegTable(k0)
li k0,CACHE_EXCEPTION
bne k0,k1,10f // check if parity exception
la k0,Monitor // Set address where to return
li t0,KSEG1_BASE // convert it to non cached
or k0,k0,t0 //
mtc0 k0,errorepc // set in errorepc
li sp, RAM_TEST_STACK_ADDRESS | KSEG1_BASE
andi a0,k1,0x3 // pass caller source in a0 just 2 bits.
eret // jump to the monitor and leave exception level
10:
la k0,Monitor // Set address where to
mtc0 k0,epc // return from the exception.
li k0,0x3
beq k0,k1,10f // if k1=3 do not change sp
andi a0,k1,0x3 // pass caller source in a0 just 2 bits.
li sp,RAM_TEST_STACK_ADDRESS // set the stack pointer.
eret // jump to the monitor and leave exception level
10: j Monitor
.end MonitorExceptionHandler
/*++
ARC_STATUS
FwInvoke(
IN ULONG ExecAddr,
IN ULONG StackAddr,
IN ULONG Argc,
IN PCHAR Argv[],
IN PCHAR Envp[]
)
Routine Description:
This routine invokes a loaded program.
Arguments:
ExecAddr - Supplies the address of the routine to call.
StackAddr - Supplies the address to which the stack pointer is set.
Argc, Argv, Envp - Supply the arguments and endvironment to pass to
Loaded program.
The stack pointer is saved in register s0 so that when the loaded
program returns, the old stack pointer can be restored.
In addition, the value stored in InvokeSavedSp is read and if zero,
this is the first loaded program, thus the current stack pointer
is the firmware stack pointer and it is saved in order to
be able to restore the Firmware stack pointer when a loaded program
calls ReturnFromMain.
Return Value:
ESUCCESS is returned if the address is valid.
EFAULT indicates an invalid addres.
--*/
{
NESTED_ENTRY(FwInvoke,0x20,zero)
subu sp,sp,0x20 // allocate room in the stack.
sw ra,0x1C(sp) // save ra
sw s0,0x18(sp) // save s0
move v1,a0 // save address of routine to call
andi v0,v1,0x3 // check for alignment.
bne v0,zero,20f // if not aligned return error.
li v0,6 // set EFAULT = 6 a return value.
move a0,a2 // move argc to first argument
move s0,sp // save stack pointer in s0
lw a2,0x30(sp) // load Envp argument into second.
move sp,a1 // set new stack pointer.
subu sp,sp,0x10 // make room for arguments.
jal v1 // call program
move a1,a3 // move argv to right argument
//
// If loaded program returns, s0 has the previous stack pointer.
//
move sp,s0 // set old stack pointer.
move v0,zero // set ESUCCESS as return value.
lw ra,0x1C(sp) // restore ra
lw s0,0x18(sp) // restore s0
20:
j ra // return to caller
addiu sp,sp,0x20 // restore sp.
.end FwInvoke
SBTTL("FwExecute")
/*++
Routine Description:
This routine is the entry point for the Execute service.
It behaves in two different ways depending on where it is
called from:
1) If it's called from the Firmware it saves the stack pointer
in a fixed location and then saves all the saved registers
in the stack. This is the stack that will be used to restore
the saved state when returning to the firmware.
2) If called from a loaded program the program to be loaded
and executed can overwrite the current program and it's
stack, therefore a temporary stack is set.
Arguments:
a0 IN PCHAR Path,
a1 IN ULONG Argc,
a2 IN PCHAR Argv[],
a3 IN PCHAR Envp[]
Return Value:
ARC_STATUS returned by FwPrivateExecute.
Always returns to the Firmware.
--*/
LEAF_ENTRY(FwExecute)
la t0, FwSavedSp // load address where to save Fw SP
lw t1, 0(t0) // read saved stack
beq t1, zero,CallFromFw // if zero first call from Fw.
nop
//
// A loaded program wants to be replaced by another program
// therefore the current stack and state will be trashed and a
// new temporary stack needs to be set.
//
la t0, FwTemporaryStack // load address of Fw temporary stack
lw sp, 0(t0) // load Tmp Stack value.
jal FwPrivateExecute // go to do the job
nop
//
// if the program returns it's caller is gone, therefore
// we restore the initiali fw stack and returned to the
// firmware instead.
//
la t0, FwSavedSp // get address of saved stack
lw sp, 0(t0) // restore saved stack.
b RestoreFwState // go to restore state
nop
CallFromFw:
subu sp,sp,0x30 // make room in the stack
sw sp, 0(t0) // save new stack
sw ra, 0x4(sp) // save also return address
sw s0, 0x8(sp) // save state that must be preserved.
sw s1, 0xC(sp)
sw s2, 0x10(sp)
sw s3, 0x14(sp)
sw s4, 0x18(sp)
sw s5, 0x1C(sp)
sw s6, 0x20(sp)
sw s7, 0x24(sp)
sw s8, 0x28(sp)
jal FwPrivateExecute // go to do the job
sw gp, 0x2C(sp) // save global pointer
RestoreFwState:
lw ra, 0x4(sp) // restore ra
lw s0, 0x8(sp) // restore Fw state
lw s1, 0xC(sp)
lw s2, 0x10(sp)
lw s3, 0x14(sp)
lw s4, 0x18(sp)
lw s5, 0x1C(sp)
lw s6, 0x20(sp)
lw s7, 0x24(sp)
lw s8, 0x28(sp)
lw gp, 0x2C(sp)
j ra // return to Firmware.
addu sp,sp,0x30 // restore sp.
.end FwExecute
SBTTL("Termination Functions")
/*++
Routine Description:
This routine implements the Firmware ReturnFromMain
termination function.
Arguments:
None.
Return Value:
returns to where the program was called from.
--*/
ALTERNATE_ENTRY(FwReturnFromMain)
la t0,FwSavedSp // get address where SP was saved
lw sp,0(t0) // set old stack pointer.
b RestoreFwState
move v0,zero // set ESUCCESS as return value.
.end FwReturnFromMain
#endif // defined(JAZZ) && defined(R4000)
