|
|
// 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"
#include "icecap.h"
#define PREF_INT_FLAG_SHIFT 14
#if (PERF_INTERRUPT_FLAG != (1 << PREF_INT_FLAG_SHIFT))
#error PERF_INTERRUPT_FLAG changed PREF_INT_FLAG_SHIFT now wrong!
#endif
.global PPerfGlobalGroupMask PublicFunction(PerfInfoLogInterrupt)
// 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)
#ifndef CAPKERN_SYNCH_POINTS
ACQUIRE_SPINLOCK(rpSpinLock, rpSpinLock, Kse10)#else
CAP_ACQUIRE_SPINLOCK(rpSpinLock, rpSpinLock, Kse10,t2,t3,t4,t5)#endif
#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)
#ifndef CAPKERN_SYNCH_POINTS
RELEASE_SPINLOCK(rpSpinLock)#else
CAP_RELEASE_SPINLOCK(rpSpinLock, t2,t3,t4,t5, pt0)#endif
#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,11,3,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 rFptr = loc8 // ISR fptr
rpI1 = t0 // temp pointer rpI2 = t1 // temp pointer rpFptr = t2 // pointer to ISR fptr rpCtxt = t3 // pointer to service context
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 out2 = @gprel(PPerfGlobalGroupMask), gp ;;
ld8.nt1 out2 = [out2] // Load PPerfGlobalGroupMask pointer 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 cmp.ne ps5 = 0, out2 // Test PPerfGlobalGroupMask point for !0 add out2 = PERF_INTERRUPT_OFFSET, out2 ;;
mov loc10 = gp // Save current GP(ps5) ld4 out2 = [out2] // Load bit mask if tracing on. ;;
(ps5) tbit.nz ps5 = out2, PREF_INT_FLAG_SHIFT // Test for interrupt tracing. //// 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
#ifndef CAPKERN_SYNCH_POINTS
ACQUIRE_SPINLOCK(rpSpinLock, rpSpinLock, Kcd_Lock)#else
CAP_ACQUIRE_SPINLOCK(rpSpinLock, rpSpinLock, Kcd_Lock,t4,t5,t6,t7)#endif
#endif // !defined(NT_UP)
add rpFptr = InServiceRoutine, out0 // pointer to fptr add rpCtxt = InServiceContext, out0 // pointer to service context ;;
LDPTR (rFptr, rpFptr) // get fptr#ifdef _CAPKERN
mov t5 = out0;;
movl out0 = @fptr(KiChainedDispatch) mov out1 = rFptr br.call.sptk.few b0=_CAP_Start_Profiling2;;
mov out0 = t5#endif
LDPTR (out1, rpCtxt) // get service context ;;
ld8.nt1 t5 = [rFptr], PlGlobalPointer-PlEntryPoint(ps5) mov loc9 = ar.itc ;;
ld8.nt1 gp = [rFptr],PlEntryPoint-PlGlobalPointer mov bt0 = t5 // set br address br.call.sptk brp = bt0 // call ISR CAPEND(KiChainedDispatch)
//// Release the service routine spin lock.//
#if !defined(NT_UP)
#ifndef CAPKERN_SYNCH_POINTS
RELEASE_SPINLOCK(rpSpinLock)#else
CAP_RELEASE_SPINLOCK(rpSpinLock, t4,t5,t6,t7, pt0)#endif
#endif
//// Lower IRQL to the interrupt source level if synchronization level is not// the same as the interrupt source level.//
PSET_IRQL(pNEqual,rIrql) mov gp=loc10 // Restore GP mov out2 = loc9 // Pass the start time.(ps5) br.spnt Kic_PerfLog
//// Get next list entry and check for end of loop.//
Kic_Return: 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
Kic_PerfLog: mov out0 = rFptr // ISR Plabel mov out1 = v0 // Pass the return value. mov loc9 = v0 // Save v0 br.call.sptk brp = PerfInfoLogInterrupt ;;
mov v0 = loc9 // Restore v0 br.sptk Kic_Return // Return to normal execution.
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 ;;
#ifdef _CAPKERN
mov t6 = out0;;
movl out0 = @fptr(KiInterruptDispatchRaise) mov out1 = t5 br.call.sptk.few b0=_CAP_Start_Profiling2;;
mov out0 = t6;;
#endif
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)
#ifndef CAPKERN_SYNCH_POINTS
ACQUIRE_SPINLOCK(rpSpinLock, rpSpinLock, Kidr_Lock)#else
CAP_ACQUIRE_SPINLOCK(rpSpinLock, rpSpinLock, Kidr_Lock,t3,t7,t8,t9)#endif
#endif // !defined(NT_UP)
;;
ld8.nt1 gp = [t5] mov bt0 = t6 // set br address br.call.sptk brp = bt0 // call ISR ;;
CAPEND(KiInterruptDispatchRaise)
//// Release the service routine spin lock.//
#if !defined(NT_UP)
#ifndef CAPKERN_SYNCH_POINTS
RELEASE_SPINLOCK(rpSpinLock)#else
CAP_RELEASE_SPINLOCK(rpSpinLock, t3,t7,t8,t9, pt0)#endif
#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) .regstk 2,8,3,0 .prologue 0x0D, loc0 alloc savedpfs=ar.pfs,2,8,3,0 mov savedbrp=brp;
mov loc2 = pr PROLOGUE_END
//// Register aliases//
rpSpinLock = loc3
////// Acquire the service routine spin lock and call the service routine.//
add loc4 = @gprel(PPerfGlobalGroupMask), gp add out0 = -InDispatchCode, a0 // -> interrupt object mov loc7 = gp // Save gp ;;
add loc5 = InServiceRoutine, out0 // addr of function pointer add t1 = InActualLock, out0 // pointer to address of lock ld8.nt1 loc4 = [loc4] // Load PPerfGlobalGroupMask pointer ;;
ld8.nt1 loc5 = [loc5] // get function pointer ld8.nt1 rpSpinLock = [t1], InServiceContext-InActualLock cmp.ne ps5 = 0, loc4 // Test PPerfGlobalGroupMask point for !0 ;;
add loc4 = PERF_INTERRUPT_OFFSET, loc4#ifndef CAPKERN_SYNCH_POINTS
ACQUIRE_SPINLOCK(rpSpinLock, rpSpinLock, Kids_Lock)#else
CAP_ACQUIRE_SPINLOCK(rpSpinLock, rpSpinLock, Kids_Lock ,t2,t3,t4,t5)#endif
#ifdef _CAPKERN
mov t5 = out0;;
movl out0 = @fptr(KiInterruptDispatchSame) mov out1 = loc5 br.call.sptk.few b0=_CAP_Start_Profiling2;;
mov out0 = t5;;
#endif
(ps5) ld4.nt1 t4 = [loc4] ld8.nt1 t5 = [loc5], PlGlobalPointer-PlEntryPoint ld8.nt1 out1 = [t1] // get service context ;;
mov bt0 = t5 // set br address(ps5) tbit.nz ps5 = t4, PREF_INT_FLAG_SHIFT
ld8.nt1 gp = [loc5],PlEntryPoint-PlGlobalPointer mov loc4 = ar.itc // Capture the current time. br.call.sptk.many brp = bt0 // call ISR ;;
CAPEND(KiInterruptDispatchSame)
//// Release the service routine spin lock.//#ifndef CAPKERN_SYNCH_POINTS
RELEASE_SPINLOCK(rpSpinLock)#else
CAP_RELEASE_SPINLOCK(rpSpinLock, t4,t5,t6,t7, pt0)#endif
(ps5) br.spnt Kids_PerfLog mov pr = loc2 NESTED_RETURN
Kids_PerfLog: mov out0 = loc5 // ISR Plabel mov gp = loc7 // Restore GP mov out1 = v0 // Pass the return value. mov out2 = loc4 // Pass the start time. br.call.sptk brp = PerfInfoLogInterrupt ;;
mov pr = loc2 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)
|
