Microsoft/Windows2000
Microsoft/Windows2000
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
45f4a58588
Windows2000/private/ntos/ke/ia64/intsup.s

775 lines
22 KiB
ArmAsm
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
// 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)
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.
//
ARGPTR (a0)
ARGPTR (a1)
add t2 = InSynchronizeIrql, a0 // -> sync IRQL
;;
ld1 t3 = [t2], InActualLock-InSynchronizeIrql
;;
#if !defined(NT_UP)
LDPTR (rpSpinLock, t2) // get address of spin lock
#endif // !defined(NT_UP)
GET_IRQL(rOldIrql) // save old IRQL
SET_IRQL(t3) // raise IRQL to synchronization IRQL
#if !defined(NT_UP)
ACQUIRE_SPINLOCK(rpSpinLock, rpSpinLock, Kse10)
#endif // !defined(NT_UP)
//
// Call specified routine passing the specified context parameter.
//
ld8 t1 = [a1], PlGlobalPointer-PlEntryPoint
;;
ld8 gp = [a1]
mov bt0 = t1 // setup br
mov out0 = a2 // get synchronize context
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,7,2,0)
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 address of listhead
add rpI1 = InMode, out0 // -> mode of interrupt
add rpI2 = InIrql, out0 // -> interrupt source IRQL
;;
ld1 rMode = [rpI1] // get mode of interrupt
ld1 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)
LDPTR (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 t5 = [rFptr], PlGlobalPointer-PlEntryPoint
;;
ld8 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 = -InInterruptListEntry, rpEntry // -> next interrupt object
;;
cmp4.eq.and pLoop1 = zero, v0 // if eq, interrupt not handled
cmp.ne.and pLoop1, pLoop2 = zero, rpEntry // if ne, not end of list
(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.
//
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
rpI1 = t1 // temp pointer
rpFptr = t2 // pointer to ISR function pointer
rpCtxt = t3 // pointer to service context
rFptr = t4 // ISR function pointer (plabel pointer)
//
// Raise IRQL to synchronization level.
//
add out0 = -InDispatchCode, a0 // out0 -> interrupt object
add rpI1 = InSynchronizeIrql-InDispatchCode, a0
;;
ld1 rSirql = [rpI1], InActualLock-InSynchronizeIrql
;;
SET_IRQL(rSirql) // raise to synchronization IRQL
//
//
// Acquire the service routine spin lock and call the service routine.
//
#if !defined(NT_UP)
LDPTR (rpSpinLock, rpI1) // get address of spin lock
;;
ACQUIRE_SPINLOCK(rpSpinLock, rpSpinLock, Kidr_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 t5 = [rFptr], PlGlobalPointer-PlEntryPoint
;;
ld8 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 // !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)
//
// Register aliases
//
rpFptr = t2 // pointer to ISR function pointer
rFptr = t4 // ISR function pointer (plabel pointer)
add a0 = -InDispatchCode, a0 // a0 points to interrupt object
;;
add rpFptr = InServiceRoutine, a0 // -> service routine fptr
add t1 = InServiceContext, a0 // -> service context
;;
LDPTR (rFptr, rpFptr) // service routine fptr
LDPTR (a1, t1) // service context
;;
ld8 t5 = [rFptr], PlGlobalPointer-PlEntryPoint
;;
ld8 gp = [rFptr]
mov bt0 = t5
br.sptk bt0 // jump 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
rpFptr = t2 // -> ISR function pointer
rpCtxt = t3 // -> service context
rFptr = t4 // ISR function pointer (plabel pointer)
//
//
// Acquire the service routine spin lock and call the service routine.
//
add out0 = -InDispatchCode, a0 // -> interrupt object
;;
add t1 = InActualLock, out0 // pointer to address of lock
add rpCtxt = InServiceContext,out0
;;
LDPTR (rpSpinLock, t1) // get address of spin lock
add rpFptr = InServiceRoutine, out0 // pointer to fptr
;;
ACQUIRE_SPINLOCK(rpSpinLock, rpSpinLock, Kids_Lock)
LDPTR (rFptr, rpFptr) // get fptr
LDPTR (out1, rpCtxt) // get service context
;;
ld8 t5 = [rFptr], PlGlobalPointer-PlEntryPoint
;;
ld8 gp = [rFptr]
mov bt0 = t5 // set br address
br.call.sptk 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
// KiDisableInterrupts (
// 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(KiDisableInterrupts)
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(KiDisableInterrupts)
//++
//
// VOID
// KiRestoreInterrupts (
// IN BOOLEAN Enable
// )
//
// Routine Description:
//
// This function restores the interrupt enable that was returned by
// the disable interrupts function.
//
// Arguments:
//
// Enable (a0) - Supplies the interrupt enable value.
//
// Return Value:
//
// None.
//
//--
LEAF_ENTRY(KiRestoreInterrupts)
dep.z t0 = a0, PSR_I, 1 // enable or disable based on input arg
;;
RESTORE_INTERRUPTS(t0)
LEAF_RETURN
LEAF_EXIT(KiRestoreInterrupts)
//++
//
// 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)
#ifdef notyet
//
// Not needed since we always save low floating point regs in TF
//
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
#endif // notyet
Reference in New Issue Copy Permalink