interrup.c

这是一个56K MODEM的驱动程序

    }
    else
    {
        /*
        // It's not our interrupt, so we don't need to service anything.
        */
        *InterruptRecognized = FALSE;
    }

    DBG_NOTICE(Adapter, ("IntrStatus=%Xh LineStatus=%Xh\n",
               InterruptStatus,
               READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1)
               ));

    DBG_LEAVE(Adapter);
}


VOID
HtDsuHandleInterrupt(
    IN PHTDSU_ADAPTER Adapter
    )

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Functional Description:

    The MiniportHandleInterrupt routine is called from within a wrapper
    deferred processing routine, and is used to process the reason an
    interrupt was generated.  The Miniport driver should handle all
    outstanding interrupts and start any new operations.

    Interrupts will be disabled during the call to this routine.

Parameters:

    MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes
                             during MiniportInitialize.

Return Values:

    None.

---------------------------------------------------------------------------*/

{
    DBG_FUNC("HtDsuHandleInterrupt")

    /*
    // A pointer to our link information structure.
    */
    PHTDSU_LINK Link;

    NdisAcquireSpinLock(&Adapter->Lock);
    Adapter->InTheDpcHandler = TRUE;

    DBG_ENTER(Adapter);

    /*
    // Loop thru here until all the interrupts are handled.
    // This should not be allowed to take more than a few mili-seconds.
    // If it does, the checked kernel will trap, and you'll have to 
    // find a way to leave the DPC early and handle the rest during 
    // the next pass.
    */
    while (Adapter->InterruptStatusFlag)
    {
        /********************************************************************
        // Do we have a packet waiting in the adapter?
        */
        if (Adapter->InterruptStatusFlag & (HTDSU_INTR_RX_PACKET1 |
                                            HTDSU_INTR_RX_PACKET2))
        {
            DBG_NOTICE(Adapter,("HTDSU_INTR_RX_PACKET\n"));

            Adapter->InterruptStatusFlag &= ~(HTDSU_INTR_RX_PACKET1 |
                                              HTDSU_INTR_RX_PACKET2);
            HtDsuReceivePacket(Adapter);
        }

        /********************************************************************
        // Has the packet been transmitted?
        // Actually, this just means that the DSU firmware has moved the
        // packet from our buffer area to its own buffer to be transmitted.
        // It won't have actually completed until HTDSU_INTR_TX_EMPTY.
        */
        if (Adapter->InterruptStatusFlag & (HTDSU_INTR_TX_PACKET1 |
                                            HTDSU_INTR_TX_PACKET2))
        {
            DBG_NOTICE(Adapter,("HTDSU_INTR_TX_PACKET\n"));

            Adapter->InterruptStatusFlag &= ~(HTDSU_INTR_TX_PACKET1 |
                                              HTDSU_INTR_TX_PACKET2);
            HtDsuTransmitComplete(Adapter);
        }
        
        /********************************************************************
        // Does somebody want to chat?
        */
        if (Adapter->InterruptStatusFlag & HTDSU_INTR_RINGING1)
        {
            DBG_NOTICE(Adapter,("HTDSU_INTR_RINGING1\n"));

            Adapter->InterruptStatusFlag &= ~HTDSU_INTR_RINGING1;
            
            /*
            // Make sure the ring is accompanied by a signal or it may
            // just be noise from the cable being unplugged.
            */
            if (CardStatusRinging(Adapter, HTDSU_CMD_LINE1) &&
                !CardStatusNoSignal(Adapter, HTDSU_CMD_LINE1))
            {
                Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE1);
                HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_RINGING);
            }
            else
            {
                DBG_WARNING(Adapter, ("Ring1 with no signal - status=%Xh\n",
                    READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1)));
            }
        }
        if (Adapter->InterruptStatusFlag & HTDSU_INTR_RINGING2)
        {
            DBG_NOTICE(Adapter,("HTDSU_INTR_RINGING2\n"));

            Adapter->InterruptStatusFlag &= ~HTDSU_INTR_RINGING2;
            
            if (CardStatusRinging(Adapter, HTDSU_CMD_LINE2) &&
                !CardStatusNoSignal(Adapter, HTDSU_CMD_LINE2))
            {
                Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE2);
                HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_RINGING);
            }
            else
            {
                DBG_WARNING(Adapter, ("Ring2 with no signal - status=%Xh\n",
                    READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine2)));
            }
        }

        /********************************************************************
        // Do we have a connection being established?
        */
        if (Adapter->InterruptStatusFlag & HTDSU_INTR_CONNECTED1)
        {
            DBG_NOTICE(Adapter,("HTDSU_INTR_CONNECTED1\n"));

            Adapter->InterruptStatusFlag &= ~HTDSU_INTR_CONNECTED1;
            
            /*
            // Make sure the connection is accompanied by a carrier and
            // an online status, Otherwise, it's probably just cable bounce.
            */
            if (CardStatusCarrierDetect(Adapter, HTDSU_CMD_LINE1) &&
                CardStatusOnLine(Adapter, HTDSU_CMD_LINE1))
            {
                Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE1);
                HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_CONNECTED);
            }
            else
            {
                DBG_WARNING(Adapter, ("Connect1 but not ready - status=%X\n",
                    READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1)));
            }
        }
        if (Adapter->InterruptStatusFlag & HTDSU_INTR_CONNECTED2)
        {
            DBG_NOTICE(Adapter,("HTDSU_INTR_CONNECTED2\n"));

            Adapter->InterruptStatusFlag &= ~HTDSU_INTR_CONNECTED2;
            
            if (CardStatusCarrierDetect(Adapter, HTDSU_CMD_LINE2) &&
                CardStatusOnLine(Adapter, HTDSU_CMD_LINE2))
            {
                Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE2);
                HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_CONNECTED);
            }
            else
            {
                DBG_WARNING(Adapter, ("Connect2 but not ready - status=%X\n",
                    READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine2)));
            }
        }

        /********************************************************************
        // Did the other guy hung up on us? -- how rude...
        */
        if (Adapter->InterruptStatusFlag & HTDSU_INTR_DISCONNECTED1)
        {
            DBG_NOTICE(Adapter,("HTDSU_INTR_DISCONNECTED1\n"));

            Adapter->InterruptStatusFlag &= ~HTDSU_INTR_DISCONNECTED1;
            
            Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE1);
            HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_DISCONNECTED);
        }
        if (Adapter->InterruptStatusFlag & HTDSU_INTR_DISCONNECTED2)
        {
            DBG_NOTICE(Adapter,("HTDSU_INTR_DISCONNECTED2\n"));

            Adapter->InterruptStatusFlag &= ~HTDSU_INTR_DISCONNECTED2;
            
            Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE2);
            HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_DISCONNECTED);
        }

        /********************************************************************
        // Has the transmitter gone idle?  Ask me if I care...
        */
        if (Adapter->InterruptStatusFlag & (HTDSU_INTR_TX_EMPTY1 |
                                            HTDSU_INTR_TX_EMPTY2))
        {
            DBG_NOTICE(Adapter,("HTDSU_INTR_TX_EMPTY\n"));

            Adapter->InterruptStatusFlag &= ~(HTDSU_INTR_TX_EMPTY1 |
                                              HTDSU_INTR_TX_EMPTY2);
        }
        
        /********************************************************************
        // Maybe somebody unplugged the phone line?
        */
        if (Adapter->InterruptStatusFlag & HTDSU_INTR_NO_SIGNAL1)
        {
            DBG_NOTICE(Adapter,("HTDSU_INTR_NO_SIGNAL1\n"));

            Adapter->InterruptStatusFlag &= ~HTDSU_INTR_NO_SIGNAL1;
            
            Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE1);
            HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_OUTOFSERVICE);
        }
        if (Adapter->InterruptStatusFlag & HTDSU_INTR_NO_SIGNAL2)
        {
            DBG_NOTICE(Adapter,("HTDSU_INTR_NO_SIGNAL2\n"));

            Adapter->InterruptStatusFlag &= ~HTDSU_INTR_NO_SIGNAL2;
            
            Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE2);
            HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_OUTOFSERVICE);
        }

        /********************************************************************
        // What about a receive buffer overrun? -- This better never happen!
        // However, if it does, we'll shut this sucker off til it's reset.
        */
        if (Adapter->InterruptStatusFlag & HTDSU_INTR_RX_FULL1)
        {
            DBG_ERROR(Adapter,("HTDSU_INTR_RX_FULL1\n"));

            Adapter->InterruptStatusFlag &= ~HTDSU_INTR_RX_FULL1;
            
            /*
            // Ask for reset, and disable interrupts until we get it.
            */
            Adapter->NeedReset = TRUE;
            Adapter->InterruptEnableFlag = HTDSU_INTR_DISABLE;
            
            Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE1);
            LinkLineError(Link, WAN_ERROR_BUFFEROVERRUN);
            HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_DISCONNECTED);
        }
        if (Adapter->InterruptStatusFlag & HTDSU_INTR_RX_FULL2)
        {
            DBG_ERROR(Adapter,("HTDSU_INTR_RX_FULL2\n"));

            Adapter->InterruptStatusFlag &= ~HTDSU_INTR_RX_FULL2;
            
            Adapter->NeedReset = TRUE;
            Adapter->InterruptEnableFlag = HTDSU_INTR_DISABLE;
            
            Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE2);
            LinkLineError(Link, WAN_ERROR_BUFFEROVERRUN);
            HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_DISCONNECTED);
        }
    }
    DBG_LEAVE(Adapter);

    Adapter->InTheDpcHandler = FALSE;
    NdisReleaseSpinLock(&Adapter->Lock);
}