607 lines
16 KiB
ArmAsm
607 lines
16 KiB
ArmAsm
// TITLE("Interrupt Object Support Routines")
|
||
//++
|
||
//
|
||
// Module Name:
|
||
//
|
||
// intsup.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:
|
||
//
|
||
// Bernard Lint 20-Nov-1995
|
||
//
|
||
// Environment:
|
||
//
|
||
// Kernel mode only.
|
||
//
|
||
// Revision History:
|
||
//
|
||
// Based on MIPS version (David N. Cutler (davec) 2-Apr-1990)
|
||
//
|
||
//--
|
||
|
||
#include "ksia64.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.
|
||
//
|
||
//--
|
||
|
||
NESTED_ENTRY(KeSynchronizeExecution)
|
||
NESTED_SETUP(3,4,1,0)
|
||
add t2 = InSynchronizeIrql, a0 // -> sync IRQL
|
||
;;
|
||
|
||
PROLOGUE_END
|
||
|
||
//
|
||
// Register aliases for entire procedure
|
||
//
|
||
|
||
rOldIrql = loc2 // saved IRQL value
|
||
rpSpinLock= loc3 // address of spin lock
|
||
|
||
//
|
||
// Raise IRQL to the synchronization level and acquire the associated
|
||
// spin lock.
|
||
//
|
||
|
||
ld8.nt1 t1 = [a1], PlGlobalPointer-PlEntryPoint
|
||
ld1.nt1 t3 = [t2], InActualLock-InSynchronizeIrql
|
||
mov out0 = a2 // get synchronize context
|
||
;;
|
||
|
||
#if !defined(NT_UP)
|
||
|
||
ld8.nt1 rpSpinLock = [t2] // get address of spin lock
|
||
|
||
#endif // !defined(NT_UP)
|
||
|
||
SWAP_IRQL (t3) // raise IRQL
|
||
|
||
#if !defined(NT_UP)
|
||
|
||
ACQUIRE_SPINLOCK(rpSpinLock, rpSpinLock, Kse10)
|
||
|
||
#endif // !defined(NT_UP)
|
||
|
||
//
|
||
// Call specified routine passing the specified context parameter.
|
||
//
|
||
|
||
ld8.nt1 gp = [a1]
|
||
mov bt0 = t1 // setup br
|
||
mov rOldIrql = v0
|
||
br.call.sptk.many brp = bt0 // call routine
|
||
|
||
//
|
||
// Release spin lock, lower IRQL to its previous level, and return the value
|
||
// returned by the specified routine.
|
||
//
|
||
|
||
#if !defined(NT_UP)
|
||
|
||
RELEASE_SPINLOCK(rpSpinLock)
|
||
|
||
#endif // !defined(NT_UP)
|
||
|
||
SET_IRQL(rOldIrql) // lower IRQL to previous level
|
||
NESTED_RETURN
|
||
NESTED_EXIT(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. Also the volatile lower floating point registers saved.
|
||
//
|
||
// N.B. gp will be destroyed by the interrupt service routine; if this code
|
||
// uses the gp of this module after the call, then it must save and
|
||
// restore gp.
|
||
//
|
||
// Arguments:
|
||
//
|
||
// a0 - Supplies a function pointer to the ISR (in the interrupt object
|
||
// dispatch code).
|
||
//
|
||
// a1 - Supplies a pointer to a trap frame.
|
||
//
|
||
// Return Value:
|
||
//
|
||
// None.
|
||
//
|
||
//--
|
||
|
||
NESTED_ENTRY(KiChainedDispatch)
|
||
NESTED_SETUP(2,8,2,0)
|
||
.save pr, loc7
|
||
mov loc7 = pr
|
||
|
||
PROLOGUE_END
|
||
|
||
//
|
||
// Register aliases
|
||
//
|
||
|
||
rpSpinLock = loc2 // pointer to spinlock
|
||
rMode = loc3 // interrupt mode (level sensitive)
|
||
rpEntry = loc4 // current list entry
|
||
rIrql = loc5 // source interrupt IRQL
|
||
rSirql = loc6 // new interrupt IRQL
|
||
rpI1 = t0 // temp pointer
|
||
rpI2 = t1 // temp pointer
|
||
rpFptr = t2 // pointer to ISR fptr
|
||
rpCtxt = t3 // pointer to service context
|
||
rFptr = t4 // ISR fptr
|
||
|
||
pLoop1 = pt1 // do another loop
|
||
pLoop2 = pt2 // do another loop
|
||
pNEqual = ps0 // true if source IRQL != sync IRQL
|
||
|
||
//
|
||
// Initialize loop variables.
|
||
//
|
||
|
||
add out0 = -InDispatchCode, a0 // out0 -> interrupt object
|
||
;;
|
||
add rpEntry = InInterruptListEntry, out0 // set addr of listhead
|
||
add rpI1 = InMode, out0 // -> mode of interrupt
|
||
add rpI2 = InIrql, out0 // -> interrupt source IRQL
|
||
;;
|
||
|
||
ld1.nt1 rMode = [rpI1] // get mode of interrupt
|
||
ld1.nt1 rIrql = [rpI2] // get interrupt source IRQL
|
||
|
||
//
|
||
// Walk the list of connected interrupt objects and call the respective
|
||
// interrupt service routines.
|
||
//
|
||
// Raise IRQL to synchronization level if synchronization level is not
|
||
// equal to the interrupt source level.
|
||
//
|
||
|
||
Kcd_Loop:
|
||
add rpI1 = InSynchronizeIrql, out0
|
||
;;
|
||
ld1 rSirql = [rpI1], InActualLock-InSynchronizeIrql
|
||
;;
|
||
|
||
cmp.ne pNEqual = rIrql, rSirql // if ne, IRQL levels are
|
||
// not the same
|
||
;;
|
||
PSET_IRQL(pNEqual, rSirql) // raise to synchronization IRQL
|
||
|
||
//
|
||
//
|
||
// Acquire the service routine spin lock and call the service routine.
|
||
//
|
||
|
||
#if !defined(NT_UP)
|
||
|
||
ld8.nt1 rpSpinLock = [rpI1] // get address of spin lock
|
||
|
||
ACQUIRE_SPINLOCK(rpSpinLock, rpSpinLock, Kcd_Lock)
|
||
|
||
#endif // !defined(NT_UP)
|
||
|
||
add rpFptr = InServiceRoutine, out0 // pointer to fptr
|
||
add rpCtxt = InServiceContext, out0 // pointer to service context
|
||
;;
|
||
LDPTR (rFptr, rpFptr) // get fptr
|
||
LDPTR (out1, rpCtxt) // get service context
|
||
;;
|
||
ld8.nt1 t5 = [rFptr], PlGlobalPointer-PlEntryPoint
|
||
;;
|
||
ld8.nt1 gp = [rFptr]
|
||
mov bt0 = t5 // set br address
|
||
br.call.sptk brp = bt0 // call ISR
|
||
|
||
//
|
||
// Release the service routine spin lock.
|
||
//
|
||
|
||
#if !defined(NT_UP)
|
||
|
||
RELEASE_SPINLOCK(rpSpinLock)
|
||
|
||
#endif
|
||
|
||
//
|
||
// Lower IRQL to the interrupt source level if synchronization level is not
|
||
// the same as the interrupt source level.
|
||
//
|
||
|
||
PSET_IRQL(pNEqual,rIrql)
|
||
|
||
//
|
||
// Get next list entry and check for end of loop.
|
||
//
|
||
|
||
add rpI1 = LsFlink, rpEntry // -> next entry
|
||
;;
|
||
LDPTR (rpEntry, rpI1) // -> next interrupt object
|
||
;;
|
||
|
||
//
|
||
// Loop if (1) interrrupt not handled and not end of list or
|
||
// if (2) interrupt handled, and not level sensistive, and not end of list
|
||
//
|
||
|
||
cmp4.eq pLoop1 = zero, zero // initialize pLoop1
|
||
cmp4.eq pLoop2 = zero, zero // initialize pLoop2
|
||
add out0 = InDispatchCode-InInterruptListEntry, rpEntry // -> ISR if done
|
||
;;
|
||
|
||
cmp4.eq.and pLoop1 = zero, v0 // if eq, interrupt not handled
|
||
cmp.ne.and pLoop1, pLoop2 = a0, out0 // if ne, not end of list
|
||
;;
|
||
add out0 = -InInterruptListEntry, rpEntry // -> next interrupt object
|
||
(pLoop1) br.dptk Kcd_Loop // loop to handle next enrty
|
||
;;
|
||
|
||
cmp4.ne.and pLoop2 = zero, v0 // if ne, interrupt handled
|
||
cmp4.ne.and pLoop2 = zero, rMode // if ne, not level sensitive
|
||
(pLoop2) br.dptk Kcd_Loop // loop to handle next enrty
|
||
;;
|
||
|
||
//
|
||
// Either the interrupt is level sensitive and has been handled or the end of
|
||
// the interrupt object chain has been reached.
|
||
//
|
||
|
||
mov pr = loc7, -2
|
||
NESTED_RETURN
|
||
NESTED_EXIT(KiChainedDispatch)
|
||
|
||
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. Also volatile lower floating point registers saved.
|
||
//
|
||
// N.B. This routine raises the interrupt level to the synchronization
|
||
// level specified in the interrupt object.
|
||
//
|
||
// N.B. gp will be destroyed by the interrupt service routine; if this code
|
||
// uses the gp of this module after the call, then it must save and
|
||
// restore gp.
|
||
//
|
||
// Arguments:
|
||
//
|
||
// a0 - Supplies a function pointer to the ISR (in the interrupt object
|
||
// dispatch code).
|
||
//
|
||
// a1 - Supplies a pointer to a trap frame.
|
||
//
|
||
// Return Value:
|
||
//
|
||
// None.
|
||
//
|
||
//--
|
||
|
||
NESTED_ENTRY(KiInterruptDispatchRaise)
|
||
NESTED_SETUP(2,4,2,0)
|
||
|
||
PROLOGUE_END
|
||
|
||
//
|
||
// Register aliases
|
||
//
|
||
|
||
rpSpinLock = loc2
|
||
rSirql = loc3 // sync IRQL
|
||
|
||
//
|
||
// Raise IRQL to synchronization level.
|
||
//
|
||
|
||
add t1 = InSynchronizeIrql-InDispatchCode, a0
|
||
add t2 = InActualLock-InDispatchCode, a0
|
||
add out0 = -InDispatchCode, a0 // out0 -> interrupt object
|
||
;;
|
||
|
||
ld1.nt1 rSirql = [t1], InActualLock-InSynchronizeIrql
|
||
#if !defined(NT_UP)
|
||
ld8.nt1 rpSpinLock = [t2] // get address of spin lock
|
||
#endif // !defined(NT_UP)
|
||
add t5 = InServiceRoutine, out0 // pointer to fptr
|
||
;;
|
||
|
||
ld8.nt1 t5 = [t5] // get function pointer
|
||
SET_IRQL (rSirql) // raise to synchronization IRQL
|
||
add t3 = InServiceContext, out0 // pointer to service context
|
||
;;
|
||
|
||
ld8.nt1 t6 = [t5], PlGlobalPointer-PlEntryPoint
|
||
ld8.nt1 out1 = [t3] // get service context
|
||
|
||
//
|
||
//
|
||
// Acquire the service routine spin lock and call the service routine.
|
||
//
|
||
|
||
#if !defined(NT_UP)
|
||
|
||
ACQUIRE_SPINLOCK(rpSpinLock, rpSpinLock, Kidr_Lock)
|
||
|
||
#endif // !defined(NT_UP)
|
||
;;
|
||
|
||
ld8.nt1 gp = [t5]
|
||
mov bt0 = t6 // set br address
|
||
br.call.sptk brp = bt0 // call ISR
|
||
;;
|
||
|
||
//
|
||
// Release the service routine spin lock.
|
||
//
|
||
|
||
#if !defined(NT_UP)
|
||
|
||
RELEASE_SPINLOCK(rpSpinLock)
|
||
|
||
#endif // !defined(NT_UP)
|
||
|
||
//
|
||
// IRQL lowered to the previous level in the external handler.
|
||
//
|
||
|
||
NESTED_RETURN
|
||
NESTED_EXIT(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. Also the volatile lower float point registers.
|
||
//
|
||
// N.B. gp will be destroyed by the interrupt service routine; if this code
|
||
// uses the gp of this module after the call, then it must save and
|
||
// restore gp.
|
||
//
|
||
// Arguments:
|
||
//
|
||
// a0 - Supplies a function pointer to the ISR (in the interrupt object
|
||
// dispatch code).
|
||
//
|
||
// a1 - Supplies a pointer to a trap frame..
|
||
//
|
||
// Return Value:
|
||
//
|
||
// None.
|
||
//
|
||
//--
|
||
|
||
#if defined(NT_UP)
|
||
|
||
LEAF_ENTRY(KiInterruptDispatchSame)
|
||
|
||
alloc t3 = ar.pfs, 2, 0, 0, 0
|
||
add a0 = -InDispatchCode, a0 // a0 points to interrupt object
|
||
;;
|
||
add t2 = InServiceRoutine, a0 // -> service routine fptr
|
||
add t1 = InServiceContext, a0 // -> service context
|
||
;;
|
||
ld8.nt1 t2 = [t2] // service routine fptr
|
||
ld8.nt1 a1 = [t1] // service context
|
||
;;
|
||
ld8.nt1 t5 = [t2], PlGlobalPointer-PlEntryPoint
|
||
;;
|
||
ld8.nt1 gp = [t2]
|
||
mov bt0 = t5
|
||
br.sptk.many bt0 // branch to service routine
|
||
|
||
//
|
||
// N.B.: Return to trap handler from ISR.
|
||
//
|
||
|
||
LEAF_EXIT(KiInterruptDispatchSame)
|
||
#else
|
||
|
||
NESTED_ENTRY(KiInterruptDispatchSame)
|
||
NESTED_SETUP(2,3,2,0)
|
||
|
||
PROLOGUE_END
|
||
|
||
//
|
||
// Register aliases
|
||
//
|
||
|
||
rpSpinLock = loc2
|
||
|
||
//
|
||
//
|
||
// Acquire the service routine spin lock and call the service routine.
|
||
//
|
||
|
||
add out0 = -InDispatchCode, a0 // -> interrupt object
|
||
;;
|
||
add t7 = InServiceRoutine, out0 // addr of function pointer
|
||
add t1 = InActualLock, out0 // pointer to address of lock
|
||
;;
|
||
|
||
ld8.nt1 t7 = [t7] // get function pointer
|
||
ld8.nt1 rpSpinLock = [t1], InServiceContext-InActualLock
|
||
add t6 = InServiceContext, out0
|
||
;;
|
||
|
||
ACQUIRE_SPINLOCK(rpSpinLock, rpSpinLock, Kids_Lock)
|
||
|
||
ld8.nt1 t5 = [t7], PlGlobalPointer-PlEntryPoint
|
||
ld8.nt1 out1 = [t1] // get service context
|
||
;;
|
||
ld8.nt1 gp = [t7]
|
||
mov bt0 = t5 // set br address
|
||
br.call.sptk.many brp = bt0 // call ISR
|
||
;;
|
||
|
||
//
|
||
// Release the service routine spin lock.
|
||
//
|
||
|
||
RELEASE_SPINLOCK(rpSpinLock)
|
||
|
||
NESTED_RETURN
|
||
|
||
NESTED_EXIT(KiInterruptDispatchSame)
|
||
#endif // !defined(NT_UP)
|
||
|
||
SBTTL("Disable Interrupts")
|
||
//++
|
||
//
|
||
// BOOLEAN
|
||
// KeDisableInterrupts (
|
||
// VOID
|
||
// )
|
||
//
|
||
// Routine Description:
|
||
//
|
||
// This function disables interrupts and returns whether interrupts
|
||
// were previously enabled.
|
||
//
|
||
// Arguments:
|
||
//
|
||
// None.
|
||
//
|
||
// Return Value:
|
||
//
|
||
// A boolean value that determines whether interrupts were previously
|
||
// enabled (TRUE) or disabled(FALSE).
|
||
//
|
||
//--
|
||
|
||
LEAF_ENTRY(KeDisableInterrupts)
|
||
|
||
DISABLE_INTERRUPTS(t0) // t0 = previous state
|
||
;;
|
||
tbit.nz pt0, pt1 = t0, PSR_I // pt0 = 1, if enabled; pt1 = 1 if disabled
|
||
;;
|
||
|
||
(pt0) mov v0 = TRUE // set return value -- TRUE if enabled
|
||
(pt1) mov v0 = FALSE // FALSE if disabled
|
||
|
||
LEAF_RETURN
|
||
LEAF_EXIT(KeDisableInterrupts)
|
||
|
||
//++
|
||
//
|
||
// VOID
|
||
// KiPassiveRelease (
|
||
// VOID
|
||
// )
|
||
//
|
||
// Routine Description:
|
||
//
|
||
// This function is called when an interrupt has been passively released.
|
||
//
|
||
// Arguments:
|
||
//
|
||
// None.
|
||
//
|
||
// Return Value:
|
||
//
|
||
// None.
|
||
//
|
||
//--
|
||
|
||
LEAF_ENTRY(KiPassiveRelease)
|
||
|
||
LEAF_RETURN
|
||
LEAF_EXIT(KiPassiveRelease)
|
||
|
||
|
||
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. Also the volatile lower float point registers.
|
||
//
|
||
// Arguments:
|
||
//
|
||
// a0 - Supplies a function pointer to the ISR (in the interrupt object
|
||
// dispatch code).
|
||
//
|
||
// a1 - Supplies a pointer to a trap frame.
|
||
//
|
||
// Return Value:
|
||
//
|
||
// None.
|
||
//
|
||
//--
|
||
|
||
LEAF_ENTRY(KiUnexpectedInterrupt)
|
||
|
||
LEAF_RETURN
|
||
LEAF_EXIT(KiUnexpectedInterrupt)
|
||
|
||
|
||
LEAF_ENTRY(KiFloatingDispatch)
|
||
|
||
LEAF_RETURN
|
||
LEAF_EXIT(KiFloatingDispatch)
|
||
|
||
|