windows-xp/Source/XPSP1/NT/net/ndis/sys/timerm.c

/*++

Copyright (c) 1990-1995  Microsoft Corporation

Module Name:

    timerm.c

Abstract:

    NDIS wrapper functions for miniport isr/timer

Author:

    Sean Selitrennikoff (SeanSe) 05-Oct-93

Environment:

    Kernel mode, FSD

Revision History:

    Jameel Hyder (JameelH) Re-organization 01-Jun-95
--*/

#include <precomp.h>
#pragma hdrstop

//
//  Define the module number for debug code.
//
#define MODULE_NUMBER   MODULE_TIMERM

//
// Timers
//
VOID
NdisMInitializeTimer(
    IN OUT PNDIS_MINIPORT_TIMER     MiniportTimer,
    IN NDIS_HANDLE                  MiniportAdapterHandle,
    IN PNDIS_TIMER_FUNCTION         TimerFunction,
    IN PVOID                        FunctionContext
    )
/*++

Routine Description:

    Sets up an Miniport Timer object, initializing the DPC in the timer to
    the function and context.

Arguments:

    MiniportTimer - the timer object.
    MiniportAdapterHandle - pointer to the mini-port block;
    TimerFunction - Routine to start.
    FunctionContext - Context of TimerFunction.

Return Value:

    None.

--*/
{
    INITIALIZE_TIMER(&MiniportTimer->Timer);

    MiniportTimer->Miniport = (PNDIS_MINIPORT_BLOCK)MiniportAdapterHandle;
    MiniportTimer->MiniportTimerFunction = TimerFunction;
    MiniportTimer->MiniportTimerContext = FunctionContext;

    //
    // Initialize our dpc. If Dpc was previously initialized, this will
    // reinitialize it.
    //
    INITIALIZE_DPC(&MiniportTimer->Dpc,
                   MINIPORT_TEST_FLAG(MiniportTimer->Miniport, fMINIPORT_DESERIALIZE) ?
                        (PKDEFERRED_ROUTINE)ndisMTimerDpcX : (PKDEFERRED_ROUTINE)ndisMTimerDpc,
                   (PVOID)MiniportTimer);

    SET_PROCESSOR_DPC(&MiniportTimer->Dpc,
                      MiniportTimer->Miniport->AssignedProcessor);
}


VOID
NdisMSetTimer(
    IN  PNDIS_MINIPORT_TIMER    MiniportTimer,
    IN  UINT                    MillisecondsToDelay
    )
/*++

Routine Description:

    Sets up TimerFunction to fire after MillisecondsToDelay.

Arguments:

    MiniportTimer       - the timer object.
    MillisecondsToDelay - Amount of time before TimerFunction is started.

Return Value:

    None.

--*/
{
    LARGE_INTEGER FireUpTime;

    FireUpTime.QuadPart = Int32x32To64((LONG)MillisecondsToDelay, -10000);

#if CHECK_TIMER
    if (MiniportTimer->Miniport->DriverHandle->Flags & fMINIBLOCK_VERIFYING)
    {
        KIRQL   OldIrql;
        PNDIS_MINIPORT_TIMER    pTimer;

        ACQUIRE_SPIN_LOCK(&MiniportTimer->Miniport->TimerQueueLock, &OldIrql);

        //
        // check to see if the timer is already set
        //
        for (pTimer = MiniportTimer->Miniport->TimerQueue;
             pTimer != NULL;
             pTimer = pTimer->NextTimer)
        {
            if (pTimer == MiniportTimer)
                break;
        }

        if (pTimer == NULL)
        {
            MiniportTimer->NextTimer = MiniportTimer->Miniport->TimerQueue;
            MiniportTimer->Miniport->TimerQueue = MiniportTimer;
        }
        
        RELEASE_SPIN_LOCK(&MiniportTimer->Miniport->TimerQueueLock, OldIrql);
    }
#endif
    //
    // Set the timer
    //
    SET_TIMER(&MiniportTimer->Timer, FireUpTime, &MiniportTimer->Dpc);
}

VOID
NdisMCancelTimer(
    IN PNDIS_MINIPORT_TIMER         Timer,
    OUT PBOOLEAN                    TimerCancelled
    )
/*++

Routine Description:

    Cancels a timer.

Arguments:

    Timer - The timer to cancel.

    TimerCancelled - TRUE if the timer was canceled, else FALSE.

Return Value:

    None

--*/
{
    if (MINIPORT_VERIFY_TEST_FLAG(Timer->Miniport, fMINIPORT_VERIFY_FAIL_CANCEL_TIMER))
    {
        *TimerCancelled = FALSE;
#if DBG
            DbgPrint("NdisMCancelTimer for Timer %p failed to verify miniport %p\n", 
                Timer, Timer->Miniport);
#endif
        
        return;
    }

    *TimerCancelled = CANCEL_TIMER(&((PNDIS_TIMER)Timer)->Timer);
#if CHECK_TIMER
    if (Timer->Miniport->DriverHandle->Flags & fMINIBLOCK_VERIFYING)
    {
        if (*TimerCancelled)
        {
            PNDIS_MINIPORT_TIMER    *pTimer;
            KIRQL                   OldIrql;
            BOOLEAN                 Dequeued = FALSE;

            ACQUIRE_SPIN_LOCK(&Timer->Miniport->TimerQueueLock, &OldIrql);

            for (pTimer = &Timer->Miniport->TimerQueue;
                 *pTimer != NULL;
                 pTimer = &(*pTimer)->NextTimer)
            {
                if (*pTimer == Timer)
                {
                    *pTimer = Timer->NextTimer;
                    Dequeued = TRUE;
                    break;
                }
            }

            RELEASE_SPIN_LOCK(&Timer->Miniport->TimerQueueLock, OldIrql);
        }
    }
#endif
}


VOID
ndisMTimerDpc(
    IN  PKDPC                       Dpc,
    IN  PVOID                       Context,
    IN  PVOID                       SystemContext1,
    IN  PVOID                       SystemContext2
    )
/*++

Routine Description:

    This function services all mini-port timer interrupts. It then calls the
    appropriate function that mini-port consumers have registered in the
    call to NdisMInitializeTimer.

Arguments:

    Dpc - Not used.

    Context - A pointer to the NDIS_MINIPORT_TIMER which is bound to this DPC.

    SystemContext1,2 - not used.

Return Value:

    None.

Note: 
    by virtue of having either the local lock or miniport spinlock, the driver's
    timer function is protected against getting unloaded .

--*/
{
    PNDIS_MINIPORT_TIMER MiniportTimer = (PNDIS_MINIPORT_TIMER)(Context);
    PNDIS_MINIPORT_BLOCK Miniport = MiniportTimer->Miniport;
    PNDIS_TIMER_FUNCTION TimerFunction;

    UNREFERENCED_PARAMETER(Dpc);
    UNREFERENCED_PARAMETER(SystemContext1);
    UNREFERENCED_PARAMETER(SystemContext2);

    NDIS_ACQUIRE_MINIPORT_SPIN_LOCK_DPC(Miniport);

    do
    {
        BLOCK_LOCK_MINIPORT_DPC_L(Miniport);

#if CHECK_TIMER
        if (Miniport->DriverHandle->Flags & fMINIBLOCK_VERIFYING)
        {
            PNDIS_MINIPORT_TIMER    *pTimer;
            BOOLEAN                 Dequeued = FALSE;
    
            ACQUIRE_SPIN_LOCK_DPC(&Miniport->TimerQueueLock);
    
            for (pTimer = &Miniport->TimerQueue;
                 *pTimer != NULL;
                 pTimer = &(*pTimer)->NextTimer)
            {
                if (*pTimer == MiniportTimer)
                {
                    //
                    // don't dequeue periodic timers when they fire
                    //
                    if (MiniportTimer->Timer.Period == 0)
                    {
                        *pTimer = MiniportTimer->NextTimer;
                    }
                    Dequeued = TRUE;
                    break;
                }
            }
        
            RELEASE_SPIN_LOCK_DPC(&Miniport->TimerQueueLock);
        }
#endif

        if (MINIPORT_TEST_FLAG(Miniport, fMINIPORT_IN_INITIALIZE))
        {
            //
            // Queue the timer as we cannot call the miniport
            //
            NdisMSetTimer(MiniportTimer, 10);

            //
            //  Unlock the miniport
            //
            UNLOCK_MINIPORT_L(Miniport);
            break;
        }
        
        //
        // if the miniport is shut down (no, I don't mean halted)
        // then don't send the timer down.
        //
        if (MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_SHUTTING_DOWN))
        {
            UNLOCK_MINIPORT_L(Miniport);
            break;
        }

        
        //
        // Call Miniport timer function
        //
        TimerFunction = MiniportTimer->MiniportTimerFunction;

        NDIS_RELEASE_MINIPORT_SPIN_LOCK_DPC(Miniport);
        
        (*TimerFunction)(NULL, MiniportTimer->MiniportTimerContext, NULL, NULL);
        
        NDIS_ACQUIRE_MINIPORT_SPIN_LOCK_DPC(Miniport);

        NDISM_PROCESS_DEFERRED(Miniport);

        UNLOCK_MINIPORT_L(Miniport);

    } while (FALSE);

    NDIS_RELEASE_MINIPORT_SPIN_LOCK_DPC(Miniport);

}


VOID
ndisMTimerDpcX(
    IN  PKDPC                       Dpc,
    IN  PVOID                       Context,
    IN  PVOID                       SystemContext1,
    IN  PVOID                       SystemContext2
    )
/*++

Routine Description:

    This function services all mini-port timer DPCs. It then calls the
    appropriate function that mini-port consumers have registered in the
    call to NdisMInitializeTimer.

Arguments:

    Dpc - Not used.

    Context - A pointer to the NDIS_MINIPORT_TIMER which is bound to this DPC.

    SystemContext1,2 - not used.

Return Value:

    None.

Note:
    we have to make sure the driver does not go away while the driver's timer function
    is running. this can happen for example if the timer function was to signal an event
    to let the Halthandler and Halt proceed.
    No need to protect the miniport here becasue we do not touch the miniport after the 
    timer function returns.

--*/
{
    PNDIS_MINIPORT_TIMER MiniportTimer = (PNDIS_MINIPORT_TIMER)(Context);
    PNDIS_MINIPORT_BLOCK Miniport = MiniportTimer->Miniport;
    PNDIS_M_DRIVER_BLOCK MiniDriver = Miniport->DriverHandle;

    UNREFERENCED_PARAMETER(Dpc);
    UNREFERENCED_PARAMETER(SystemContext1);
    UNREFERENCED_PARAMETER(SystemContext2);
    
    //
    // make sure the driver does not go away while the timer function
    // is running
    ndisReferenceDriver(MiniDriver);
    
#if CHECK_TIMER
    if (MiniportTimer->Miniport->DriverHandle->Flags & fMINIBLOCK_VERIFYING)
    {
        PNDIS_MINIPORT_TIMER    *pTimer;
        KIRQL                   OldIrql;
        BOOLEAN                 Dequeued = FALSE;

        ACQUIRE_SPIN_LOCK_DPC(&MiniportTimer->Miniport->TimerQueueLock);

        for (pTimer = &Miniport->TimerQueue;
             *pTimer != NULL;
             pTimer = &(*pTimer)->NextTimer)
        {
            if (*pTimer == MiniportTimer)
            {
                //
                // don't dequeue periodic timers when they fire
                //
                if (MiniportTimer->Timer.Period == 0)
                {
                    *pTimer = MiniportTimer->NextTimer;
                }
                Dequeued = TRUE;
                break;
            }
        }

        RELEASE_SPIN_LOCK_DPC(&MiniportTimer->Miniport->TimerQueueLock);
    }
#endif

    //
    // if the miniport is shut down (no, I don't mean halted)
    // then don't send the timer down.
    //
    if (!MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_SHUTTING_DOWN))
    {
        (*MiniportTimer->MiniportTimerFunction)(NULL, MiniportTimer->MiniportTimerContext, NULL, NULL);
    }

    //
    // this can be called at DPC
    //
    ndisDereferenceDriver(MiniDriver, FALSE);

}

NDIS_STATUS
NdisMRegisterInterrupt(
    OUT PNDIS_MINIPORT_INTERRUPT    Interrupt,
    IN NDIS_HANDLE                  MiniportAdapterHandle,
    IN UINT                         InterruptVector,
    IN UINT                         InterruptLevel,
    IN BOOLEAN                      RequestIsr,
    IN BOOLEAN                      SharedInterrupt,
    IN NDIS_INTERRUPT_MODE          InterruptMode
    )
{
    PNDIS_MINIPORT_BLOCK            Miniport = (PNDIS_MINIPORT_BLOCK)MiniportAdapterHandle;
    NDIS_STATUS Status;

    Interrupt->Reserved = (PVOID)Miniport->MiniportAdapterContext;
    Miniport->Interrupt = (PNDIS_MINIPORT_INTERRUPT)Interrupt;

    Status = ndisMRegisterInterruptCommon(
                                Interrupt,
                                MiniportAdapterHandle,
                                InterruptVector,
                                InterruptLevel,
                                RequestIsr,
                                SharedInterrupt,
                                InterruptMode);


    if (Status != NDIS_STATUS_SUCCESS)
    {
        Miniport->Interrupt = NULL;
    }

    return Status;
}


VOID
NdisMDeregisterInterrupt(
    IN  PNDIS_MINIPORT_INTERRUPT    MiniportInterrupt
    )
{
    DBGPRINT(DBG_COMP_INIT, DBG_LEVEL_INFO,
            ("==>NdisMDeregisterInterrupt: Miniport %p\n", MiniportInterrupt->Miniport));
    do
    {
        if (MiniportInterrupt->InterruptObject == NULL)
            break;

        ndisMDeregisterInterruptCommon(MiniportInterrupt);
        
        MiniportInterrupt->Miniport->Interrupt = NULL;
    } while (FALSE);

    DBGPRINT(DBG_COMP_INIT, DBG_LEVEL_INFO,
            ("<==NdisMDeregisterInterrupt: Miniport %p\n", MiniportInterrupt->Miniport));
}


BOOLEAN
NdisMSynchronizeWithInterrupt(
    IN PNDIS_MINIPORT_INTERRUPT     Interrupt,
    IN PVOID                        SynchronizeFunction,
    IN PVOID                        SynchronizeContext
    )
{
    return (SYNC_WITH_ISR((Interrupt)->InterruptObject,
                          SynchronizeFunction,
                          SynchronizeContext));
}


VOID
ndisMWakeUpDpcX(
    IN  PKDPC                       Dpc,
    IN  PVOID                       Context,
    IN  PVOID                       SystemContext1,
    IN  PVOID                       SystemContext2
    )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
    PNDIS_MINIPORT_BLOCK        Miniport = (PNDIS_MINIPORT_BLOCK)(Context);
    BOOLEAN                     Hung = FALSE;
    PNDIS_MINIPORT_WORK_ITEM    WorkItem;
    NDIS_STATUS                 Status;
    BOOLEAN                     AddressingReset = FALSE;
    BOOLEAN                     fDontReset = FALSE;

    UNREFERENCED_PARAMETER(Dpc);
    UNREFERENCED_PARAMETER(SystemContext1);
    UNREFERENCED_PARAMETER(SystemContext2);

    do
    {
        //
        //  If the miniport is halting then do nothing.
        //
        if (MINIPORT_TEST_FLAG(Miniport, fMINIPORT_PM_HALTING))
        {
            break;
        }
    
        Miniport->CFHangCurrentTick--;
        if (Miniport->CFHangCurrentTick == 0)
        {
            Miniport->CFHangCurrentTick = Miniport->CFHangTicks;

            //
            // Call Miniport stall checker.
            //
            if (Miniport->DriverHandle->MiniportCharacteristics.CheckForHangHandler != NULL)
            {
                Hung = (Miniport->DriverHandle->MiniportCharacteristics.CheckForHangHandler)(Miniport->MiniportAdapterContext);
            }
        
            //
            //  Was there a request to reset the device?
            //
            if (MINIPORT_TEST_FLAG(Miniport, fMINIPORT_RESTORING_FILTERS))
            {
                Hung = FALSE;
                break;
            }
        
            NDIS_ACQUIRE_MINIPORT_SPIN_LOCK_DPC(Miniport);
        
            //
            //  Check the internal wrapper states for the miniport and
            //  see if we think the miniport should be reset.
            //
            if (!Hung)
            {
                //
                //  Should we check the request queue?
                //  Did a request pend too long?
                //
                if (!MINIPORT_TEST_FLAG(Miniport, fMINIPORT_IGNORE_REQUEST_QUEUE) &&
                    MINIPORT_TEST_FLAG(Miniport, fMINIPORT_PROCESSING_REQUEST))
                {
                    if (MINIPORT_TEST_FLAG(Miniport, fMINIPORT_REQUEST_TIMEOUT))
                    {
                        Miniport->InternalResetCount ++;
                        Hung = TRUE;
                    }
                    else
                    {
                        if (Miniport->CFHangXTicks == 0)
                        {
                            MINIPORT_SET_FLAG(Miniport, fMINIPORT_REQUEST_TIMEOUT);
                        }
                        else
                        {
                            Miniport->CFHangXTicks--;
                        }
                    }
                }
            }
            else
            {
                Miniport->MiniportResetCount ++;
            }
        
            if (Hung)
            {
                if (NULL != Miniport->DriverHandle->MiniportCharacteristics.ResetHandler)
                {
                    if ((MINIPORT_TEST_FLAG(Miniport, fMINIPORT_RESET_IN_PROGRESS)) ||
                        (MINIPORT_PNP_TEST_FLAG(Miniport, fMINIPORT_HALTING)))
                    {
                        fDontReset = TRUE;
                    }
                    else
                    {
                        MINIPORT_SET_FLAG(Miniport, fMINIPORT_RESET_IN_PROGRESS);
                        Miniport->ResetOpen = NULL;
                    }
                
                    ndisMSwapOpenHandlers(Miniport, 
                                          NDIS_STATUS_RESET_IN_PROGRESS,
                                          fMINIPORT_STATE_RESETTING);
                }
                else Hung = FALSE;
            }
        
    
            if (Hung && !fDontReset)
            {
                MINIPORT_SET_FLAG(Miniport, fMINIPORT_CALLING_RESET);

                //
                // wait for all the requests to come back.
                // note: this is not the same as waiting for all requests to complete
                // we just make sure the original request call has come back
                //
                do
                {
                    if (Miniport->RequestCount == 0)
                    {
                        break;
                    }
                    else
                    {
                        NDIS_RELEASE_MINIPORT_SPIN_LOCK_DPC(Miniport);
                        NDIS_INTERNAL_STALL(50);
                        NDIS_ACQUIRE_MINIPORT_SPIN_LOCK_DPC(Miniport);
                    }
                } while (TRUE);

                NDIS_RELEASE_MINIPORT_SPIN_LOCK_DPC(Miniport);

                NdisMIndicateStatus(Miniport, NDIS_STATUS_RESET_START, NULL, 0);
                NdisMIndicateStatusComplete(Miniport);
        
                DBGPRINT(DBG_COMP_WORK_ITEM, DBG_LEVEL_INFO,
                    ("Calling miniport reset\n"));
        
                //
                //  Call the miniport's reset handler.
                //
                Status = (Miniport->DriverHandle->MiniportCharacteristics.ResetHandler)(
                                          &AddressingReset,
                                          Miniport->MiniportAdapterContext);
                
                if (NDIS_STATUS_PENDING != Status)
                {
                    NdisMResetComplete(Miniport, Status, AddressingReset);
                }
            }
            else
            {
                NDIS_RELEASE_MINIPORT_SPIN_LOCK_DPC(Miniport);
            }
        }

        if (!Hung)
        {
            if (MINIPORT_TEST_FLAG(Miniport, fMINIPORT_REQUIRES_MEDIA_POLLING) == TRUE)
            {
                NDIS_ACQUIRE_MINIPORT_SPIN_LOCK_DPC(Miniport);
                ndisMPollMediaState(Miniport);
                NDIS_RELEASE_MINIPORT_SPIN_LOCK_DPC(Miniport);
            }
        }
    } while (FALSE);
}


VOID
ndisMWakeUpDpc(
    IN  PKDPC                       Dpc,
    IN  PVOID                       Context,
    IN  PVOID                       SystemContext1,
    IN  PVOID                       SystemContext2
    )
/*++

Routine Description:

    This function services all mini-port. It checks to see if a mini-port is
    ever stalled.

Arguments:

    Dpc - Not used.

    Context - A pointer to the NDIS_TIMER which is bound to this DPC.

    SystemContext1,2 - not used.

Return Value:

    None.

--*/
{
    PNDIS_MINIPORT_BLOCK        Miniport = (PNDIS_MINIPORT_BLOCK)(Context);
    BOOLEAN                     Hung = FALSE;
    BOOLEAN                     LocalLock;
    PNDIS_MINIPORT_WORK_ITEM    WorkItem;

    UNREFERENCED_PARAMETER(Dpc);
    UNREFERENCED_PARAMETER(SystemContext1);
    UNREFERENCED_PARAMETER(SystemContext2);

    NDIS_ACQUIRE_MINIPORT_SPIN_LOCK_DPC(Miniport);

    do
    {
        //
        //  If the miniport is halting then do nothing.
        //
        if (MINIPORT_TEST_FLAG(Miniport, fMINIPORT_PM_HALTING))
        {
            break;
        }

        //
        //  Can we get the miniport lock. If not then quit. This is not time-critical
        //  and we can try again next tick
        //
        LOCK_MINIPORT(Miniport, LocalLock);
        if (!LocalLock ||
            MINIPORT_TEST_FLAG(Miniport, (fMINIPORT_RESET_IN_PROGRESS | fMINIPORT_RESET_REQUESTED)))
        {
            UNLOCK_MINIPORT(Miniport, LocalLock);
            break;
        }
    
        Miniport->CFHangCurrentTick--;
        if (Miniport->CFHangCurrentTick == 0)
        {
            Miniport->CFHangCurrentTick = Miniport->CFHangTicks;
    
            //
            // Call Miniport stall checker.
            //
            if (Miniport->DriverHandle->MiniportCharacteristics.CheckForHangHandler != NULL)
            {
                NDIS_RELEASE_MINIPORT_SPIN_LOCK_DPC(Miniport);
                Hung = (Miniport->DriverHandle->MiniportCharacteristics.CheckForHangHandler)(Miniport->MiniportAdapterContext);
                NDIS_ACQUIRE_MINIPORT_SPIN_LOCK_DPC(Miniport);
            }
        
            if (MINIPORT_TEST_FLAG(Miniport, fMINIPORT_RESTORING_FILTERS))
            {
                //
                //  We are restoring filters post reset. Don't pre-empt again
                //
                Hung = FALSE;
                UNLOCK_MINIPORT(Miniport, LocalLock);
                break;
            }

            //
            //  Check the internal wrapper states for the miniport and
            //  see if we think the miniport should be reset.
            //
            if (Hung)
            {
                Miniport->MiniportResetCount ++;
            }
            else do
            {
                //
                //  Should we check the request queue ?  Did a request pend too long ?
                //
                if ((Miniport->Flags & (fMINIPORT_IGNORE_REQUEST_QUEUE|fMINIPORT_PROCESSING_REQUEST)) == fMINIPORT_PROCESSING_REQUEST)
                {
                    if (MINIPORT_TEST_FLAG(Miniport, fMINIPORT_REQUEST_TIMEOUT))
                    {
                        Miniport->InternalResetCount ++;
                        Hung = TRUE;
                        break;
                    }
                    else
                    {
                        if (Miniport->CFHangXTicks == 0)
                        {
                            MINIPORT_SET_FLAG(Miniport, fMINIPORT_REQUEST_TIMEOUT);
                        }
                        else
                        {
                            Miniport->CFHangXTicks--;
                        }
                            
                    }
                }
    
                //
                //  Should we check the packet queue ? Did a packet pend too long ?
                //
                if (!MINIPORT_TEST_FLAG(Miniport, fMINIPORT_IGNORE_PACKET_QUEUE))
                {
                    PNDIS_PACKET    Packet;
    
                    GET_FIRST_MINIPORT_PACKET(Miniport, &Packet);
    
                    //
                    //  Does the miniport have possession of any packets?
                    //
                    if ((Packet != NULL) &&
                        MINIPORT_TEST_PACKET_FLAG(Packet, fPACKET_PENDING))
                    {
                        //
                        //  Has the packet timed out?
                        //
                        if (MINIPORT_TEST_PACKET_FLAG(Packet, fPACKET_HAS_TIMED_OUT))
                        {
                            //
                            //  Reset the miniport.
                            //
                            Miniport->InternalResetCount ++;
                            Hung = TRUE;
                        }
                        else
                        {
                            //
                            //  Set the packet flag and wait to see if it is still
                            //  there next time in.
                            //
                            MINIPORT_SET_PACKET_FLAG(Packet, fPACKET_HAS_TIMED_OUT);
                        }
                    }
                    else
                    {
                        break;
                    }
        
                    //
                    //  If we are hung then we don't need to check for token ring errors.
                    //
                    if (Hung)
                    {
                        break;
                    }
                }
    
                //
                //  Are we ignoring token ring errors?
                //
                if (!MINIPORT_TEST_FLAG(Miniport, fMINIPORT_IGNORE_TOKEN_RING_ERRORS))
                {
                    //
                    //  Token Ring reset...
                    //
                    if (Miniport->TrResetRing == 1)
                    {
                        Miniport->InternalResetCount ++;
                        Hung = TRUE;
                        break;
                    }
                    else if (Miniport->TrResetRing > 1)
                    {
                        Miniport->TrResetRing--;
                    }
                }
            } while (FALSE);
    
            //
            //  If the miniport is hung then queue a workitem to reset it.
            //
            if (Hung)
            {
                if (!MINIPORT_TEST_FLAG(Miniport, fMINIPORT_RESTORING_FILTERS))
                {
                    if (NULL != Miniport->DriverHandle->MiniportCharacteristics.ResetHandler)
                    {
                        NDISM_QUEUE_WORK_ITEM(Miniport, NdisWorkItemResetRequested, NULL);
                    }
                }
            }
        }

        if (!Hung)
        {
            if (MINIPORT_TEST_FLAG(Miniport, fMINIPORT_REQUIRES_MEDIA_POLLING) == TRUE)
            {
                ndisMPollMediaState(Miniport);
            }
        }

        //
        // Process any changes that have occurred.
        //
        NDISM_PROCESS_DEFERRED(Miniport);

        UNLOCK_MINIPORT_L(Miniport);

    } while (FALSE);

    NDIS_RELEASE_MINIPORT_SPIN_LOCK_DPC(Miniport);
}


BOOLEAN
ndisMIsr(
    IN PKINTERRUPT                  KInterrupt,
    IN PVOID                        Context
    )
/*++

Routine Description:

    Handles ALL Miniport interrupts, calling the appropriate Miniport ISR and DPC
    depending on the context.

Arguments:

    Interrupt - Interrupt object for the Mac.

    Context - Really a pointer to the interrupt.

Return Value:

    None.

--*/
{
    PNDIS_MINIPORT_INTERRUPT Interrupt = (PNDIS_MINIPORT_INTERRUPT)Context;
    PNDIS_MINIPORT_BLOCK     Miniport = Interrupt->Miniport;
    BOOLEAN                  InterruptRecognized;
    BOOLEAN                  IsrCalled = FALSE, QueueDpc = FALSE;

    do
    {   
        if (MINIPORT_TEST_FLAG(Miniport, fMINIPORT_NORMAL_INTERRUPTS))
        {
            MINIPORT_DISABLE_INTERRUPT_EX(Miniport, Interrupt);

            InterruptRecognized = QueueDpc = TRUE;
        }
        else
        {
            IsrCalled = TRUE;
//            Interrupt->MiniportIsr(&InterruptRecognized,
//                                   &QueueDpc,
//                                   Miniport->MiniportAdapterContext);
            Interrupt->MiniportIsr(&InterruptRecognized,
                                   &QueueDpc,
                                   Interrupt->Reserved);
        }

        if (QueueDpc)
        {
            InterlockedIncrement((PLONG)&Interrupt->DpcCount);

            if (QUEUE_DPC(&Interrupt->InterruptDpc))
            {
                break;
            }

            //
            // The DPC was already queued, so we have an extra reference (we
            // do it this way to ensure that the reference is added *before*
            // the DPC is queued).
            InterlockedDecrement((PLONG)&Interrupt->DpcCount);

            break;
        }

        if (!IsrCalled)
        {
            if (!Interrupt->SharedInterrupt &&
                !Interrupt->IsrRequested &&
                !MINIPORT_TEST_FLAG(Miniport, fMINIPORT_IN_INITIALIZE))
            {
                ASSERT(Miniport->DisableInterruptHandler != NULL);
    
                MINIPORT_DISABLE_INTERRUPT_EX(Miniport, Interrupt);
                InterruptRecognized = TRUE;
                break;
            }

            //
            // Call MiniportIsr, but don't queue a DPC.
            //
//            Interrupt->MiniportIsr(&InterruptRecognized,
//                                   &QueueDpc,
//                                   Miniport->MiniportAdapterContext);

            Interrupt->MiniportIsr(&InterruptRecognized,
                                   &QueueDpc,
                                   Interrupt->Reserved);
            
        }

    } while (FALSE);

    return(InterruptRecognized);
}


VOID
ndisMDpc(
    IN PVOID                        SystemSpecific1,
    IN PVOID                        InterruptContext,
    IN PVOID                        SystemSpecific2,
    IN PVOID                        SystemSpecific3
    )
/*++

Routine Description:

    Handles ALL Miniport interrupt DPCs, calling the appropriate Miniport DPC
    depending on the context.

Arguments:

    Interrupt - Interrupt object for the Mac.

    Context - Really a pointer to the Interrupt.

Return Value:

    None.

--*/
{
    PNDIS_MINIPORT_INTERRUPT Interrupt = (PNDIS_MINIPORT_INTERRUPT)(InterruptContext);
    PNDIS_MINIPORT_BLOCK     Miniport = Interrupt->Miniport;

    W_HANDLE_INTERRUPT_HANDLER MiniportDpc = Interrupt->MiniportDpc;

    NDIS_ACQUIRE_MINIPORT_SPIN_LOCK_DPC(Miniport);

    do
    {
        if (MINIPORT_TEST_FLAG(Miniport, (fMINIPORT_PM_HALTING)) ||
            Interrupt->DpcCountLock)
        {
            InterlockedDecrement((PLONG)&Interrupt->DpcCount);

            if (Interrupt->DpcCount==0)
            {
                SET_EVENT(&Interrupt->DpcsCompletedEvent);
            }

            break;
        }

        BLOCK_LOCK_MINIPORT_DPC_L(Miniport);
        
        NDIS_RELEASE_MINIPORT_SPIN_LOCK_DPC(Miniport);
//        (*MiniportDpc)(Miniport->MiniportAdapterContext);
        (*MiniportDpc)(Interrupt->Reserved);

        NDIS_ACQUIRE_MINIPORT_SPIN_LOCK_DPC(Miniport);
        
        InterlockedDecrement((PLONG)&Interrupt->DpcCount);

        MINIPORT_SYNC_ENABLE_INTERRUPT_EX(Miniport, Interrupt);
        
        NDISM_PROCESS_DEFERRED(Miniport);

        UNLOCK_MINIPORT(Miniport, TRUE);

    } while (FALSE);

    NDIS_RELEASE_MINIPORT_SPIN_LOCK_DPC(Miniport);
}


VOID
ndisMDpcX(
    IN PVOID SystemSpecific1,
    IN PVOID InterruptContext,
    IN PVOID SystemSpecific2,
    IN PVOID SystemSpecific3
    )
/*++

Routine Description:

    Handles ALL Miniport interrupt DPCs, calling the appropriate Miniport DPC
    depending on the context.

Arguments:

    Interrupt - Interrupt object for the Mac.

    Context - Really a pointer to the Interrupt.

Return Value:

    None.

--*/
{
    PNDIS_MINIPORT_INTERRUPT    Interrupt = (PNDIS_MINIPORT_INTERRUPT)(InterruptContext);
    PNDIS_MINIPORT_BLOCK        Miniport = Interrupt->Miniport;

    W_HANDLE_INTERRUPT_HANDLER MiniportDpc = Interrupt->MiniportDpc;

    if (MINIPORT_TEST_FLAG(Miniport, (fMINIPORT_PM_HALTING)) ||
        Interrupt->DpcCountLock)
    {
        InterlockedDecrement((PLONG)&Interrupt->DpcCount);

        if (Interrupt->DpcCount==0)
        {
            SET_EVENT(&Interrupt->DpcsCompletedEvent);
        }
    }
    else
    {
        //(*MiniportDpc)(Miniport->MiniportAdapterContext);
        (*MiniportDpc)(Interrupt->Reserved);

        InterlockedDecrement((PLONG)&Interrupt->DpcCount);

        MINIPORT_SYNC_ENABLE_INTERRUPT_EX(Miniport, Interrupt);
    }
}


VOID
ndisMDeferredDpc(
    IN  PKDPC                       Dpc,
    IN  PVOID                       Context,
    IN  PVOID                       SystemContext1,
    IN  PVOID                       SystemContext2
    )

/*++

Routine Description:

    This is a DPC routine that is queue'd by some of the [full-duplex] routines
    in order to get ndisMProcessDeferred to run outside of their
    context.

Arguments:



Return Value:

    None.

--*/
{
    PNDIS_MINIPORT_BLOCK    Miniport = Context;

    UNREFERENCED_PARAMETER(Dpc);
    UNREFERENCED_PARAMETER(SystemContext1);
    UNREFERENCED_PARAMETER(SystemContext2);

    NDIS_ACQUIRE_MINIPORT_SPIN_LOCK_DPC(Miniport);

    BLOCK_LOCK_MINIPORT_DPC_L(Miniport);

    NDISM_PROCESS_DEFERRED(Miniport);

    UNLOCK_MINIPORT(Miniport, TRUE);

    NDIS_RELEASE_MINIPORT_SPIN_LOCK_DPC(Miniport);
}



NDIS_STATUS
NdisMRegisterInterruptEx(
    OUT PNDIS_MINIPORT_INTERRUPT_EX Interrupt,
    IN NDIS_HANDLE                  MiniportAdapterHandle,
    IN UINT                         InterruptVector,
    IN UINT                         InterruptLevel,
    IN BOOLEAN                      RequestIsr,
    IN BOOLEAN                      SharedInterrupt,
    IN NDIS_INTERRUPT_MODE          InterruptMode
    )
{
    PNDIS_MINIPORT_BLOCK            Miniport = (PNDIS_MINIPORT_BLOCK)MiniportAdapterHandle;
    NDIS_STATUS Status;
    KIRQL       OldIrql;
    
    Interrupt->InterruptContext = (PVOID)Interrupt;

    NDIS_ACQUIRE_MINIPORT_SPIN_LOCK(Miniport, &OldIrql);

    Interrupt->NextInterrupt = (PNDIS_MINIPORT_INTERRUPT_EX)Miniport->Interrupt;
    Miniport->Interrupt = (PNDIS_MINIPORT_INTERRUPT)Interrupt;
    
    NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);

    Status = ndisMRegisterInterruptCommon(
                                (PNDIS_MINIPORT_INTERRUPT)Interrupt,
                                MiniportAdapterHandle,
                                InterruptVector,
                                InterruptLevel,
                                RequestIsr,
                                SharedInterrupt,
                                InterruptMode);

    if (Status != NDIS_STATUS_SUCCESS)
    {
        PNDIS_MINIPORT_INTERRUPT_EX *ppQ;
        
        PnPReferencePackage();
        
        NDIS_ACQUIRE_MINIPORT_SPIN_LOCK(Miniport, &OldIrql);
        
        for (ppQ = (PNDIS_MINIPORT_INTERRUPT_EX *)&Miniport->Interrupt;
             *ppQ != NULL;
             ppQ = &(*ppQ)->NextInterrupt)
        {
            if (*ppQ == Interrupt)
            {
                *ppQ = Interrupt->NextInterrupt;
                break;
            }
        }
        
        PnPDereferencePackage();
        
        NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);
    }

    return Status;
}

VOID
NdisMDeregisterInterruptEx(
    IN  PNDIS_MINIPORT_INTERRUPT_EX     MiniportInterrupt
    )
{
    PNDIS_MINIPORT_BLOCK        Miniport = MiniportInterrupt->Miniport;
    PNDIS_MINIPORT_INTERRUPT_EX *ppQ;
    KIRQL                       OldIrql;
    
            
    DBGPRINT(DBG_COMP_INIT, DBG_LEVEL_INFO,
            ("==>NdisMDeregisterInterruptEx: Miniport %p\n", MiniportInterrupt->Miniport));

    ndisMDeregisterInterruptCommon((PNDIS_MINIPORT_INTERRUPT)MiniportInterrupt);

    PnPReferencePackage();

    NDIS_ACQUIRE_MINIPORT_SPIN_LOCK(Miniport, &OldIrql);
    
    for (ppQ = (PNDIS_MINIPORT_INTERRUPT_EX *)&Miniport->Interrupt;
         *ppQ != NULL;
         ppQ = &(*ppQ)->NextInterrupt)
    {
        if (*ppQ == MiniportInterrupt)
        {
            *ppQ = MiniportInterrupt->NextInterrupt;
            break;
        }
    }
    
    NDIS_RELEASE_MINIPORT_SPIN_LOCK(Miniport, OldIrql);
    
    PnPDereferencePackage();
        
    DBGPRINT(DBG_COMP_INIT, DBG_LEVEL_INFO,
            ("<==NdisMDeregisterInterruptEx: Miniport %p\n", MiniportInterrupt->Miniport));

}

NDIS_STATUS
ndisMRegisterInterruptCommon(
    OUT PNDIS_MINIPORT_INTERRUPT    Interrupt,
    IN NDIS_HANDLE                  MiniportAdapterHandle,
    IN UINT                         InterruptVector,
    IN UINT                         InterruptLevel,
    IN BOOLEAN                      RequestIsr,
    IN BOOLEAN                      SharedInterrupt,
    IN NDIS_INTERRUPT_MODE          InterruptMode
    )
{
    PNDIS_MINIPORT_BLOCK            Miniport = (PNDIS_MINIPORT_BLOCK)MiniportAdapterHandle;
    ULONG                           Vector;
    NDIS_STATUS                     Status;
    NTSTATUS                        NtStatus;
    KIRQL                           Irql;
    KAFFINITY                       InterruptAffinity;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR pResourceDescriptor;
    PHYSICAL_ADDRESS                NonTranslatedInterrupt, TranslatedIrql;
    
    DBGPRINT(DBG_COMP_INIT, DBG_LEVEL_INFO,
            ("==>ndisMRegisterInterruptCommon: Miniport %p\n", MiniportAdapterHandle));

    if (MINIPORT_VERIFY_TEST_FLAG((PNDIS_MINIPORT_BLOCK)MiniportAdapterHandle, fMINIPORT_VERIFY_FAIL_INTERRUPT_REGISTER))
    {
    #if DBG
        DbgPrint("NdisMRegisterInterrupt failed to verify miniport %p\n", MiniportAdapterHandle);
    #endif
        return NDIS_STATUS_RESOURCES;
    }

    do
    {
        Status = NDIS_STATUS_SUCCESS;
        InterlockedIncrement(&Miniport->RegisteredInterrupts);

        //
        // We must do this stuff first because if we connect the
        // interrupt first then an interrupt could occur before
        // the ISR is recorded in the Ndis interrupt structure.
        //
        Interrupt->DpcCount = 0;
        Interrupt->DpcCountLock = 0;
        Interrupt->Miniport = Miniport;
        Interrupt->MiniportIsr = Miniport->DriverHandle->MiniportCharacteristics.ISRHandler;
        Interrupt->MiniportDpc = Miniport->HandleInterruptHandler;
        Interrupt->SharedInterrupt = SharedInterrupt;
        Interrupt->IsrRequested = RequestIsr;

        //
        // This is used to tell when all Dpcs are completed after the
        // interrupt has been removed.
        //
        INITIALIZE_EVENT(&Interrupt->DpcsCompletedEvent);
        
        INITIALIZE_DPC(&Interrupt->InterruptDpc,
                   MINIPORT_TEST_FLAG(Miniport, fMINIPORT_DESERIALIZE) ?
                        ndisMDpcX : ndisMDpc,
                   Interrupt);

        SET_DPC_IMPORTANCE(&Interrupt->InterruptDpc);
    
        SET_PROCESSOR_DPC(&Interrupt->InterruptDpc,
                          Miniport->AssignedProcessor);

        NonTranslatedInterrupt.QuadPart = InterruptLevel;
        Status = ndisTranslateResources(Miniport,
                                        CmResourceTypeInterrupt,
                                        NonTranslatedInterrupt,
                                        &TranslatedIrql,
                                        &pResourceDescriptor);
        if (NDIS_STATUS_SUCCESS != Status)
        {
            DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
                    (("    NdisMRegisterInterrupt: trying to register interrupt %p which is not allocated to device\n"),
                    InterruptLevel));
                    
            Status = NDIS_STATUS_FAILURE;
            break;
        }

        Irql = (KIRQL)pResourceDescriptor->u.Interrupt.Level;
        Vector = pResourceDescriptor->u.Interrupt.Vector;
        InterruptAffinity = pResourceDescriptor->u.Interrupt.Affinity;


        if (pResourceDescriptor->Flags == CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE)
        {
            InterruptMode = LevelSensitive;
        }
        else 
        {
            InterruptMode = Latched;
        }
    
        //
        // just in case this is not the first time we try to get an interrupt
        // for this miniport (suspend/resume or if the miniport has decided to
        // let go of interrupt and hook it again
        //
        MINIPORT_CLEAR_FLAG(Miniport, fMINIPORT_DEREGISTERED_INTERRUPT);

        NtStatus = IoConnectInterrupt(&Interrupt->InterruptObject,
                                      (PKSERVICE_ROUTINE)ndisMIsr,
                                      Interrupt,
                                      NULL,
                                      Vector,
                                      Irql,
                                      Irql,
                                      (KINTERRUPT_MODE)InterruptMode,
                                      SharedInterrupt,
                                      InterruptAffinity,
                                      FALSE);

        if (!NT_SUCCESS(NtStatus))
        {
            Status = NDIS_STATUS_FAILURE;

            DBGPRINT_RAW(DBG_COMP_INIT, DBG_LEVEL_INFO,
                    (("    NdisMRegisterInterrupt: IoConnectInterrupt failed on Interrupt Level:%lx, Vector: %lx\n"),
                    Irql, Vector));

            //
            // zero out the interrupt object just in case driver tries to remove the interrupt
            // they are aligned in both structures
            //
            Interrupt->InterruptObject = NULL;
        }

    } while (FALSE);


    if (Status != NDIS_STATUS_SUCCESS)
    {
        InterlockedDecrement(&Miniport->RegisteredInterrupts);
    }

                            
    DBGPRINT(DBG_COMP_INIT, DBG_LEVEL_INFO,
            ("<==ndisMRegisterInterruptCommon: Miniport %p, Status %lx\n", MiniportAdapterHandle, Status));
            
    return Status;
}



VOID
ndisMDeregisterInterruptCommon(
    IN  PNDIS_MINIPORT_INTERRUPT    MiniportInterrupt
    )
{
    LARGE_INTEGER               TimeoutValue;
    PNDIS_MINIPORT_BLOCK        Miniport = MiniportInterrupt->Miniport;

    DBGPRINT(DBG_COMP_INIT, DBG_LEVEL_INFO,
            ("==>ndisMDeregisterInterruptCommon: Miniport %p\n", MiniportInterrupt->Miniport));

    do
    {
        //
        // drivers can register interrupts only during initialization
        // and deregister them only during halt
        // so here we can safely set the flag after the ref count
        // goes to zero.
        //
        if (InterlockedDecrement(&Miniport->RegisteredInterrupts) == 0)
        {
            MINIPORT_SET_FLAG(MiniportInterrupt->Miniport, fMINIPORT_DEREGISTERED_INTERRUPT);
        }

        //
        // overloading the DpcCountLock to say that interrupt is
        // deregistered
        //
        (ULONG)MiniportInterrupt->DpcCountLock = 1;
        
        //
        //  Now we disconnect the interrupt.
        //  NOTE: they are aligned in both structures
        //
        IoDisconnectInterrupt(MiniportInterrupt->InterruptObject);

        //
        // Right now we know that any Dpcs that may fire are counted.
        // We don't have to guard this with a spin lock because the
        // Dpc will set the event it completes first, or we may
        // wait for a little while for it to complete.
        //
        TimeoutValue.QuadPart = Int32x32To64(1000, -10000); // Make it 1 second
        if (MiniportInterrupt->DpcCount > 0)
        {
            //
            // Now we wait for all dpcs to complete.
            //
            WAIT_FOR_OBJECT(&MiniportInterrupt->DpcsCompletedEvent, &TimeoutValue);
    
            RESET_EVENT(&MiniportInterrupt->DpcsCompletedEvent);
        }

    } while (FALSE);
    
    DBGPRINT(DBG_COMP_INIT, DBG_LEVEL_INFO,
            ("<==ndisMDeregisterInterruptCommon: Miniport %p\n", MiniportInterrupt->Miniport));
}