#if defined(JAZZ) && defined(R3000)

/*++

Copyright (c) 1990  Microsoft Corporation

Module Name:

    j3inter.s

Abstract:

    This module contains the interrupt dispatcher and various interrupt
    routines for the selftest. The exception dispatcher resides in rom
    because the BEV bit in the psr is set.

Author:

    Lluis Abello (lluis)  8-May-91

Environment:

    Executes in kernal mode.


Revision History:


--*/
#include "led.h"
#include "ksmips.h"
#include "trap.h"
#include "interupt.h"
#include "jzconfig.h"
#include "dmaregs.h"
#include <jazzprom.h>
//
// PROM entry point definitions.
// Define base address of prom entry vector and prom entry macro.
//
#define PROM_BASE (KSEG1_BASE | 0x1fc00000)
#define PROM_ENTRY(x) (PROM_BASE + ((x) * 8))


#define PutLedDisplay PROM_ENTRY(14)
 .globl TimerTicks
 .data
InterruptTable: 	    // vector of 8 interrupt handler pointers
    .word  0:8		    // initialy set to zero.
DeviceIntTable: 	    // vector of 10 device interrupt handler pointers
    .word  0:10 	    // initialy set to zero.
InterruptNotExpectedMsg:
    .ascii  "\r\nInterrupt    not expected.\r\n\0"
#define IntOffset 12
TimerTicks:		    // Counter of timer ticks. Decremented by Timer interrupt handler.
    .word  0
.text
    .set noreorder
    .set noat
//
//++
//ConnectInterrupts
//
// Routine Description:
//
//	This routine initializes the interrupt table with pointers to
//	the interrupt handlers.
//
//	Handlers for the following interrupts are installed:
//	    MCT_ADR Interval Timer
//	    Sonic
//	    Video
//	    Sound
//
//	It also enables interrupts.
//
// Arguments:
//
//	None.
//
// Return Value:
//
//	None.
//
//--

	LEAF_ENTRY(ConnectInterrupts)
	//
	// Initialize the interrupt dispatch table
	//
	la	t0,InterruptTable		// get address of table
	la	t1,DeviceInt			// address of routine
	sw	t1,DEVICE_INT*4(t0)		// store in table
	la	t1,IntervalTimerInt		// get address of routine
	sw	t1,TIMER_INT*4(t0)		// store it in table
	//
	// Initialize the device interrupt dispatch table
	//
	la	t0,DeviceIntTable		// get address of table
	la	t1,SonicInterrupt		// address of handler
	sw	t1,INTR_SRC_LAN(t0)		// store in table
	la	t1,VideoInterrupt		// address of handler
	sw	t1,INTR_SRC_VIDEO(t0)		// store in table
//	la	t1,SoundInterrupt		// address of handler
//	sw	t1,INTR_SRC_SOUND(t0)		// store in table
	//
	// Initialize the exception dispatch table
	//
	li	t0,EXCEPTION_JUMP_TABLE 	// lookup table
	la	t1,InterruptDispatcher		// address of interrupt disp
	sw	t1,EXCEPTION_INT(t0)		// write in proper entry.

	//
	// Enable interrupts.
	//
	li	t0,(1<< PSR_BEV)+(1<<PSR_IEC)+(INT_MASK<<PSR_INTMASK)
	mtc0	t0,psr
	nop
	j	ra
	nop
	.end	ConnectInterrupts


//++
// InterruptDispatcher
//
// Routine Description:
//
//	This routine is called as a result of an interrupt
//	It looks in the interrupt dispatch table for a handler and
//	jumps to it if it founds any.
//	This routine is called from rom. The interrupt handler executes
//	a 'j ra' to go back to the rom code which will execute the rfe.
//
//
//
//
// Arguments:
//
//	None.
//
// Return Value:
//
//--

	LEAF_ENTRY (InterruptDispatcher)
	subu	sp,sp,IntFrameSize	    // make room in the stack
	sw	t0,IntFrameT0(sp)	    // save temporay registers
	sw	t1,IntFrameT1(sp)
	sw	t2,IntFrameT2(sp)
	sw	t3,IntFrameT3(sp)
	sw	t4,IntFrameT4(sp)
	sw	t5,IntFrameT5(sp)
	sw	t6,IntFrameT6(sp)
	sw	t7,IntFrameT7(sp)
	sw	t8,IntFrameT8(sp)
	sw	t9,IntFrameT9(sp)
	sw	AT,IntFrameAT(sp)
	sw	a0,IntFrameA0(sp)
	sw	a1,IntFrameA1(sp)
	sw	a2,IntFrameA2(sp)
	sw	a3,IntFrameA3(sp)
	sw	v0,IntFrameV0(sp)
	sw	v1,IntFrameV1(sp)
	sw	ra,IntFrameRa(sp)
	mfc0	t1,cause		    // get cause register
	mfc0	t2,psr			    // get psr register
	la	t0,InterruptTable	    // get address of interrupt table.
	and	t2,t2,t1		    // and them to discard disabled interrupts
	li	t3,0x20 		    // Index of table
CheckNextInt:
	andi	t4,t2,(1<<15)		    // check for interrupt starting with higher priority
	bne	t4,zero,JumpToInterrupt     //
	subu	t3,t3,0x4		    // Next table index
	bne	t3,zero,CheckNextInt
	sll	t2,t2,1 		    // shift IntPend field to check next
JumpToInterrupt:			    // t3 has the interrupt index
	addu	t0,t0,t3		    // add offset to table
	lw	t0,0(t0)		    // get routine address
	nop
	bne	t0,zero,GoToHandler
	nop
	jal	HandlerForNoHandlers
	ori	a0,t3,0xC0		    // a0 has the encoded interrupt number
	j	ExitInterrupt
	nop
GoToHandler:
	jal	t0
	nop
ExitInterrupt:
	li	k0,GOTO_EPC		    // tell dispatcher to return normally
	lw	ra,IntFrameRa(sp)	    // restore stack
	lw	t0,IntFrameT0(sp)	    // restore temporay registers
	lw	t1,IntFrameT1(sp)
	lw	t2,IntFrameT2(sp)
	lw	t3,IntFrameT3(sp)
	lw	t4,IntFrameT4(sp)
	lw	t5,IntFrameT5(sp)
	lw	t6,IntFrameT6(sp)
	lw	t7,IntFrameT7(sp)
	lw	t8,IntFrameT8(sp)
	lw	t9,IntFrameT9(sp)
	lw	AT,IntFrameAT(sp)
	lw	a0,IntFrameA0(sp)
	lw	a1,IntFrameA1(sp)
	lw	a2,IntFrameA2(sp)
	lw	a3,IntFrameA3(sp)
	lw	v0,IntFrameV0(sp)
	lw	v1,IntFrameV1(sp)
	j	ra			    // return to rom exception dispatch
	addu	sp,sp,IntFrameSize	    // restore stack
    .end	InterruptDispatcher

//
//++
//DeviceInt
//
// Routine Description:
//
//	This routine is called as a result of a Hardware Interrupt 1
//	This is a device interrupt. The routine reads the interrupt
//	source register sand dispatches to the proper interrupt handler
//
// Arguments:
//
//	None.
//
// Return Value:
//
//	None.
//
//--

	LEAF_ENTRY(DeviceInt)
	li	t0,INTERRUPT_VIRTUAL_BASE   // address of interrupt source reg
	lbu	a0,0(t0)		    // read interrupt
	la	t0, DeviceIntTable	    // base address of dispatch table.
	addu	t0,t0,a0		    // add offset to base
	lw	t0,0(t0)		    // read handler address
	nop
	beq	t0,zero,HandlerForNoHandlers// hang diplay something in the led
	nop
	j	t0			    // go to routine.
	nop
	.end DeviceInt


//++
//VideoInterrupt
//
// Routine Description:
//
//	This routine is called as a result of a video interrupt.
//	It does nothing is just here no to take a video interrupt as
//	an error.
//
// Arguments:
//
//	None.
//
// Return Value:
//
//	None.
//
//--

	LEAF_ENTRY(VideoInterrupt)
	j	ra			    // return to caller.
	nop
	.end VideoInterrupt

//
//++
//IntervalTimerInt
//
// Routine Description:
//
//	This routine is called as a result of a Hardware Interrupt 4
//	This is an Interval timer interrupt. The routine decrements a counter
//	used for timeout.
//	A test that needs timeout facilites must set the number of milliseconds
//	into the TimerTicks variable and poll it until it's zero.
//
// Arguments:
//
//	None.
//
// Return Value:
//
//	None.
//
//--

	LEAF_ENTRY(IntervalTimerInt)
	la	t5,TimerTicks		    // get address of counter
	lw	t2,0(t5)		    // read counter
	li	t1,DMA_VIRTUAL_BASE	    // base address of MCTADR
	beq	t2,zero,NoDecrement
	lw	t1,DmaIntervalTimer(t1)     // read register to clear int.
	addiu	t2,t2,-1		    // decrement counter by one
NoDecrement:
	j	ra			    // return to caller.
	sw	t2,0(t5)		    // store new counter value
	.end IntervalTimerInt

//
//++
//HandlerForNoHandlers
//
// Routine Description:
//
//	This routine is called when an interrupt is received and no handler
//	as been set for it.
//
// Arguments:
//
//	None.
//
// Return Value:
//
//	None.
//
//--

    LEAF_ENTRY(HandlerForNoHandlers)
        srl     t0,a0,4                         // get second digit
	andi	t0,t0,0xF
	slti	t1,t0,10
	bne	t1,zero,10f			// branch if 0-9
	addiu	t0,t0,0x30			 // addjust value
        addiu   t0,t0,0x41-0x30-10               // readjust value if A-F
10:
	andi	t1,a0,0xF			// get less significant digit
	slti	t2,t1,10
	bne	t2,zero,10f			// branch if 0-9
	addiu	t1,t1,0x30			 // addjust value
        addiu   t1,t1,0x41-0x30-10                // readjust value if A-F
10:
	la	a0,InterruptNotExpectedMsg	// get message address
        sb      t0,IntOffset(a0)                // write 1st digit interrupt#
        jal     FwPrint                         // display error
        sb      t1,IntOffset+1(a0)              // write 2nd digit interrupt#
	li	t0,PutLedDisplay		// get address of led
	lui	a0,LED_BLINK
	jal	t0
	ori	a0,a0,LED_NOT_INTERRUPT
    .end    HandlerForNoHandlers
//
//++
//DisableInterrupt
//
// Routine Description:
//
//	This routine disables interrupts.  By clearing the IEc bit in the psr
//
// Arguments:
//
//	None.
//
// Return Value:
//
//	None.
//
//--

    LEAF_ENTRY(DisableInterrupts)
        li      t0,(1<< PSR_BEV)
	mtc0	t0,psr
	j	ra
	nop
    .end DisableInterrupts
#endif  //JAZZ && R3000