// 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)