// TITLE("Interrupt Object Support Routines")
//++
//
// Copyright (c) 1990 Microsoft Corporation
//
// Module Name:
//
// xxintsup.s
//
// Abstract:
//
// This module implements the code necessary to support interrupt objects.
// It contains the interrupt dispatch code and the code template that gets
// copied into an interrupt object.
//
// Author:
//
// David N. Cutler (davec) 2-Apr-1990
//
// Environment:
//
// Kernel mode only.
//
// Revision History:
//
//--
#include "ksmips.h"
SBTTL("Synchronize Execution")
//++
//
// BOOLEAN
// KeSynchronizeExecution (
// IN PKINTERRUPT Interrupt,
// IN PKSYNCHRONIZE_ROUTINE SynchronizeRoutine,
// IN PVOID SynchronizeContext
// )
//
// Routine Description:
//
// This function synchronizes the execution of the specified routine with the
// execution of the service routine associated with the specified interrupt
// object.
//
// Arguments:
//
// Interrupt (a0) - Supplies a pointer to a control object of type interrupt.
//
// SynchronizeRoutine (a1) - Supplies a pointer to a function whose execution
// is to be synchronized with the execution of the service routine associated
// with the specified interrupt object.
//
// SynchronizeContext (a2) - Supplies a pointer to an arbitrary data structure
// which is to be passed to the function specified by the SynchronizeRoutine
// parameter.
//
// Return Value:
//
// The value returned by the SynchronizeRoutine function is returned as the
// function value.
//
//--
.struct 0
SyArg: .space 4 * 4 // argument register save area
SyS0: .space 4 // saved integer register s0
SyIrql: .space 4 // saved IRQL value
.space 4 // fill for alignment
SyRa: .space 4 // saved return address
SyFrameLength: // length of stack frame
SyA0: .space 4 // saved argument registers a0 - a2
SyA1: .space 4 //
SyA2: .space 4 //
NESTED_ENTRY(KeSynchronizeExecution, SyFrameLength, zero)
subu sp,sp,SyFrameLength // allocate stack frame
sw ra,SyRa(sp) // save return address
sw s0,SyS0(sp) // save integer register s0
PROLOGUE_END
sw a1,SyA1(sp) // save synchronization routine address
sw a2,SyA2(sp) // save synchronization routine context
//
// Raise IRQL to the synchronization level and acquire the associated
// spin lock.
//
#if defined(R4000) && !defined(NT_UP)
lw s0,InActualLock(a0) // get address of spin lock
#endif
lbu a0,InSynchronizeIrql(a0) // get synchronization IRQL
addu a1,sp,SyIrql // compute address to save IRQL
jal KeRaiseIrql // raise IRQL to synchronization IRQL
#if defined(R4000) && !defined(NT_UP)
10: ll t0,0(s0) // get current lock value
move t1,s0 // set lock ownership value
bne zero,t0,10b // if ne, spin lock owned
sc t1,0(s0) // set spin lock owned
beq zero,t1,10b // if eq, store conditional failed
#endif
//
// Call specified routine passing the specified context parameter.
//
lw t0,SyA1(sp) // get synchronize routine address
lw a0,SyA2(sp) // get synchronize routine context
jal t0 // call specified routine
//
// Release spin lock, lower IRQL to its previous level, and return the value
// returned by the specified routine.
//
#if defined(R4000) && !defined(NT_UP)
sw zero,0(s0) // set spin lock not owned
#endif
lbu a0,SyIrql(sp) // get saved IRQL
move s0,v0 // save return value
jal KeLowerIrql // lower IRQL to previous level
move v0,s0 // set return value
lw s0,SyS0(sp) // restore integer register s0
lw ra,SyRa(sp) // restore return address
addu sp,sp,SyFrameLength // deallocate stack frame
j ra // return
.end KeSynchronizeExecution
SBTTL("Chained Dispatch")
//++
//
// Routine Description:
//
// This routine is entered as the result of an interrupt being generated
// via a vector that is connected to more than one interrupt object. Its
// function is to walk the list of connected interrupt objects and call
// each interrupt service routine. If the mode of the interrupt is latched,
// then a complete traversal of the chain must be performed. If any of the
// routines require saving the volatile floating point machine state, then
// it is only saved once.
//
// N.B. On entry to this routine only the volatile integer registers have
// been saved.
//
// Arguments:
//
// a0 - Supplies a pointer to the interrupt object.
//
// s8 - Supplies a pointer to a trap frame.
//
// Return Value:
//
// None.
//
//--
.struct 0
ChArg: .space 4 * 4 // argument register save area
ChS0: .space 4 // saved integer registers s0 - s6
ChS1: .space 4 //
ChS2: .space 4 //
ChS3: .space 4 //
ChS4: .space 4 //
ChS5: .space 4 //
ChS6: .space 4 //
ChRa: .space 4 // saved return address
ChFrameLength: // length of stack frame
ChIrql: .space 4 // saved IRQL value
NESTED_ENTRY(KiChainedDispatch, ChFrameLength, zero)
subu sp,sp,ChFrameLength // allocate stack frame
sw ra,ChRa(sp) // save return address
sw s0,ChS0(sp) // save integer registers s0 - s6
sw s1,ChS1(sp) //
sw s2,ChS2(sp) //
sw s3,ChS3(sp) //
sw s4,ChS4(sp) //
sw s5,ChS5(sp) //
#if defined(R4000) && !defined(NT_UP)
sw s6,ChS6(sp) //
#endif
PROLOGUE_END
//
// Initialize loop variables.
//
addu s0,a0,InInterruptListEntry // set address of listhead
move s1,s0 // set address of first entry
move s2,zero // clear floating state saved flag
lbu s3,InMode(a0) // get mode of interrupt
lbu s4,InIrql(a0) // get interrupt source IRQL
//
// Walk the list of connected interrupt objects and call the respective
// interrupt service routines.
//
10: subu a0,s1,InInterruptListEntry // compute interrupt object address
lbu t0,InFloatingSave(a0) // get floating save flag
bne zero,s2,20f // if ne, floating state already saved
beq zero,t0,20f // if eq, don't save floating state
//
// Save volatile floating registers f0 - f19 in trap frame.
//
SAVE_VOLATILE_FLOAT_STATE // save volatile floating state
li s2,1 // set floating state saved flag
//
// Raise IRQL to synchronization level if synchronization level is not
// equal to the interrupt source level.
//
20: lbu s5,InSynchronizeIrql(a0) // get synchronization IRQL
beq s4,s5,25f // if eq, IRQL levels are the same
move a0,s5 // set synchronization IRQL
addu a1,sp,ChIrql // compute address to save IRQL
jal KeRaiseIrql // raise to synchronization IRQL
subu a0,s1,InInterruptListEntry // recompute interrupt object address
//
//
// Acquire the service routine spin lock and call the service routine.
//
25: //
#if defined(R4000) && !defined(NT_UP)
lw s6,InActualLock(a0) // get address of spin lock
30: ll t1,0(s6) // get current lock value
move t2,s6 // set lock ownership value
bne zero,t1,30b // if ne, spin lock owned
sc t2,0(s6) // set spin lock owned
beq zero,t2,30b // if eq, store conditional failed
#endif
lw t0,InServiceRoutine(a0) // get address of service routine
lw a1,InServiceContext(a0) // get service context
jal t0 // call service routine
//
// Release the service routine spin lock.
//
#if defined(R4000) && !defined(NT_UP)
sw zero,0(s6) // set spin lock not owned
#endif
//
// Lower IRQL to the interrupt source level if synchronization level is not
// the same as the interrupt source level.
//
beq s4,s5,35f // if eq, IRQL levels are the same
move a0,s4 // set interrupt source IRQL
jal KeLowerIrql // lower to interrupt source IRQL
//
// Get next list entry and check for end of loop.
//
35: lw s1,LsFlink(s1) // get next interrupt object address
beq zero,v0,40f // if eq, interrupt not handled
beq zero,s3,50f // if eq, level sensitive interrupt
40: bne s0,s1,10b // if ne, not end of list
//
// Either the interrupt is level sensitive and has been handled or the end of
// the interrupt object chain has been reached. Check to determine if floating
// machine state needs to be restored.
//
50: beq zero,s2,60f // if eq, floating state not saved
//
// Restore volatile floating registers f0 - f19 from trap frame.
//
RESTORE_VOLATILE_FLOAT_STATE // restore volatile floating state
//
// Restore integer registers s0 - s6, retrieve return address, deallocate
// stack frame, and return.
//
60: lw s0,ChS0(sp) // restore integer registers s0 - s6
lw s1,ChS1(sp) //
lw s2,ChS2(sp) //
lw s3,ChS3(sp) //
lw s4,ChS4(sp) //
lw s5,ChS5(sp) //
#if defined(R4000) && !defined(NT_UP)
lw s6,ChS6(sp) //
#endif
lw ra,ChRa(sp) // restore return address
addu sp,sp,ChFrameLength // deallocate stack frame
j ra // return
.end KiChainedDispatch
SBTTL("Floating Dispatch")
//++
//
// Routine Description:
//
// This routine is entered as the result of an interrupt being generated
// via a vector that is connected to an interrupt object. Its function is
// to save the volatile floating machine state and then call the specified
// interrupt service routine.
//
// N.B. On entry to this routine only the volatile integer registers have
// been saved.
//
// Arguments:
//
// a0 - Supplies a pointer to the interrupt object.
//
// s8 - Supplies a pointer to a trap frame.
//
// Return Value:
//
// None.
//
//--
.struct 0
FlArg: .space 4 * 4 // argument register save area
FlS0: .space 4 // saved integer registers s0 - s1
FlS1: .space 4 //
FlIrql: .space 4 // saved IRQL value
FlRa: .space 4 // saved return address
FlFrameLength: // length of stack frame
NESTED_ENTRY(KiFloatingDispatch, FlFrameLength, zero)
subu sp,sp,FlFrameLength // allocate stack frame
sw ra,FlRa(sp) // save return address
sw s0,FlS0(sp) // save integer registers s0 - s1
#if defined(R4000) && !defined(NT_UP)
sw s1,FlS1(sp) //
#endif
PROLOGUE_END
//
// Save volatile floating registers f0 - f19 in trap frame.
//
SAVE_VOLATILE_FLOAT_STATE // save volatile floating state
//
// Raise IRQL to synchronization level if synchronization level is not
// equal to the interrupt source level.
//
move s0,a0 // save address of interrupt object
lbu a0,InSynchronizeIrql(s0) // get synchronization IRQL
lbu t0,InIrql(s0) // get interrupt source IRQL
beq a0,t0,10f // if eq, IRQL levels are the same
addu a1,sp,FlIrql // compute address to save IRQL
jal KeRaiseIrql // raise to synchronization IRQL
10: move a0,s0 // restore address of interrupt object
//
//
// Acquire the service routine spin lock and call the service routine.
//
#if defined(R4000) && !defined(NT_UP)
lw s1,InActualLock(a0) // get address of spin lock
20: ll t1,0(s1) // get current lock value
move t2,s1 // set lock ownership value
bne zero,t1,20b // if ne, spin lock owned
sc t2,0(s1) // set spin lock owned
beq zero,t2,20b // if eq, store conditional failed
#endif
lw t0,InServiceRoutine(a0) // get address of service routine
lw a1,InServiceContext(a0) // get service context
jal t0 // call service routine
//
// Release the service routine spin lock.
//
#if defined(R4000) && !defined(NT_UP)
sw zero,0(s1) // set spin lock not owned
#endif
//
// Lower IRQL to the interrupt source level if synchronization level is not
// the same as the interrupt source level.
//
lbu a0,InIrql(s0) // get interrupt source IRQL
lbu t0,InSynchronizeIrql(s0) // get synchronization IRQL
beq a0,t0,30f // if eq, IRQL levels are the same
jal KeLowerIrql // lower to interrupt source IRQL
//
// Restore volatile floating registers f0 - f19 from trap frame.
//
30: RESTORE_VOLATILE_FLOAT_STATE // restore volatile floating state
//
// Restore integer registers s0 - s1, retrieve return address, deallocate
// stack frame, and return.
//
lw s0,FlS0(sp) // restore integer registers s0 - s1
#if defined(R4000) && !defined(NT_UP)
lw s1,FlS1(sp) //
#endif
lw ra,FlRa(sp) // restore return address
addu sp,sp,FlFrameLength // deallocate stack frame
j ra // return
.end KiFloatingDispatch
SBTTL("Interrupt Dispatch - Raise IRQL")
//++
//
// Routine Description:
//
// This routine is entered as the result of an interrupt being generated
// via a vector that is connected to an interrupt object. Its function is
// to directly call the specified interrupt service routine.
//
// N.B. On entry to this routine only the volatile integer registers have
// been saved.
//
// N.B. This routine raises the interrupt level to the synchronization
// level specified in the interrupt object.
//
// Arguments:
//
// a0 - Supplies a pointer to the interrupt object.
//
// s8 - Supplies a pointer to a trap frame.
//
// Return Value:
//
// None.
//
//--
.struct 0
RdArg: .space 4 * 4 // argument register save area
RdS0: .space 4 // saved integer register s0
.space 4 // fill
RdIrql: .space 4 // saved IRQL value
RdRa: .space 4 // saved return address
RdFrameLength: // length of stack frame
NESTED_ENTRY(KiInterruptDispatchRaise, RdFrameLength, zero)
subu sp,sp,RdFrameLength // allocate stack frame
sw ra,RdRa(sp) // save return address
sw s0,RdS0(sp) // save integer register s0
PROLOGUE_END
//
// Raise IRQL to synchronization level.
//
move s0,a0 // save address of interrupt object
lbu a0,InSynchronizeIrql(s0) // get synchronization IRQL
addu a1,sp,RdIrql // compute address to save IRQL
jal KeRaiseIrql // raise to synchronization IRQL
move a0,s0 // restore address of interrupt object
//
//
// Acquire the service routine spin lock and call the service routine.
//
#if defined(R4000) && !defined(NT_UP)
lw s0,InActualLock(a0) // get address of spin lock
10: ll t1,0(s0) // get current lock value
move t2,s0 // set lock ownership value
bne zero,t1,10b // if ne, spin lock owned
sc t2,0(s0) // set spin lock owned
beq zero,t2,10b // if eq, store conditional failed
#endif
lw t0,InServiceRoutine(a0) // get address of service routine
lw a1,InServiceContext(a0) // get service context
jal t0 // call service routine
//
// Release the service routine spin lock.
//
#if defined(R4000) && !defined(NT_UP)
sw zero,0(s0) // set spin lock not owned
#endif
//
// Lower IRQL to the previous level.
//
lbu a0,RdIrql(sp) // get previous IRQL
jal KeLowerIrql // lower to interrupt source IRQL
//
// Restore integer register s0, retrieve return address, deallocate
// stack frame, and return.
//
lw s0,RdS0(sp) // restore integer registers s0 - s1
lw ra,RdRa(sp) // restore return address
addu sp,sp,RdFrameLength // deallocate stack frame
j ra // return
.end KiInterruptDispatchRaise
SBTTL("Interrupt Dispatch - Same IRQL")
//++
//
// Routine Description:
//
// This routine is entered as the result of an interrupt being generated
// via a vector that is connected to an interrupt object. Its function is
// to directly call the specified interrupt service routine.
//
// N.B. On entry to this routine only the volatile integer registers have
// been saved.
//
// Arguments:
//
// a0 - Supplies a pointer to the interrupt object.
//
// s8 - Supplies a pointer to a trap frame.
//
// Return Value:
//
// None.
//
//--
#if defined(NT_UP)
LEAF_ENTRY(KiInterruptDispatchSame)
lw t0,InServiceRoutine(a0) // get address of service routine
lw a1,InServiceContext(a0) // get service context
j t0 // jump to service routine
#else
.struct 0
SdArg: .space 4 * 4 // argument register save area
SdS0: .space 4 // saved integer register s0
.space 4 * 2 // fill
SdRa: .space 4 // saved return address
SdFrameLength: // length of stack frame
NESTED_ENTRY(KiInterruptDispatchSame, SdFrameLength, zero)
subu sp,sp,SdFrameLength // allocate stack frame
sw ra,SdRa(sp) // save return address
sw s0,SdS0(sp) // save integer register s0
PROLOGUE_END
//
//
// Acquire the service routine spin lock and call the service routine.
//
lw s0,InActualLock(a0) // get address of spin lock
10: ll t1,0(s0) // get current lock value
move t2,s0 // set lock ownership value
bne zero,t1,10b // if ne, spin lock owned
sc t2,0(s0) // set spin lock owned
beq zero,t2,10b // if eq, store conditional failed
lw t0,InServiceRoutine(a0) // get address of service routine
lw a1,InServiceContext(a0) // get service context
jal t0 // call service routine
//
// Release the service routine spin lock.
//
sw zero,0(s0) // set spin lock not owned
//
// Restore integer register s0, retrieve return address, deallocate
// stack frame, and return.
//
lw s0,SdS0(sp) // restore integer registers s0 - s1
lw ra,SdRa(sp) // restore return address
addu sp,sp,SdFrameLength // deallocate stack frame
j ra // return
#endif
.end KiInterruptDispatchSame
SBTTL("Interrupt Template")
//++
//
// Routine Description:
//
// This routine is a template that is copied into each interrupt object. Its
// function is to determine the address of the respective interrupt object
// and then transfer control to the appropriate interrupt dispatcher.
//
// N.B. On entry to this routine only the volatile integer registers have
// been saved.
//
// Arguments:
//
// a0 - Supplies a pointer to the interrupt template within an interrupt
// object.
//
// s8 - Supplies a pointer to a trap frame.
//
// Return Value:
//
// None.
//
//--
LEAF_ENTRY(KiInterruptTemplate)
.set noreorder
.set noat
lw t0,InDispatchAddress - InDispatchCode(a0) // get dispatcher address
subu a0,a0,InDispatchCode // compute address of interrupt object
j t0 // transfer control to dispatch routine
nop //
.set at
.set reorder
.end KiInterruptTemplate
SBTTL("Unexpected Interrupt")
//++
//
// Routine Description:
//
// This routine is entered as the result of an interrupt being generated
// via a vector that is not connected to an interrupt object. Its function
// is to report the error and dismiss the interrupt.
//
// N.B. On entry to this routine only the volatile integer registers have
// been saved.
//
// Arguments:
//
// a0 - Supplies a pointer to the interrupt object.
//
// s8 - Supplies a pointer to a trap frame.
//
// Return Value:
//
// None.
//
//--
LEAF_ENTRY(KiUnexpectedInterrupt)
j ra // ****** temp ******
.end KiUnexpectedInterrupt
