/***************************************************************************\
|* Copyright (c) 1994 Microsoft Corporation *|
|* Developed for Microsoft by TriplePoint, Inc. Beaverton, Oregon *|
|* *|
|* This file is part of the HT Communications DSU41 WAN Miniport Driver. *|
\***************************************************************************/
#include "version.h"
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Module Name:
interrup.c
Abstract:
This module contains the Miniport interrupt processing routines:
MiniportCheckForHang()
MiniportDisableInterrupt()
MiniportEnableInterrupt()
MiniportISR()
MiniportHandleInterrupt()
This driver conforms to the NDIS 3.0 Miniport interface.
Author:
Larry Hattery - TriplePoint, Inc. (larryh@tpi.com) Jun-94
Environment:
Windows NT 3.5 kernel mode Miniport driver or equivalent.
Revision History:
---------------------------------------------------------------------------*/
#define __FILEID__ 3 // Unique file ID for error logging
#include "htdsu.h"
BOOLEAN
HtDsuCheckForHang(
IN PHTDSU_ADAPTER Adapter
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
The MiniportCheckForHang request is used by the wrapper to periodically
have the miniport check if the adapter appears hung.
The Miniport driver should do nothing more than check the internal state
and return if the adapter is hung. The wrapper will then attempt to
recover the adapter by calling MiniportReset.
This routine will be called once every two seconds.
Interrupts will be in any state when called.
Parameters:
MiniportAdapterContext _ The handle returned from MiniportInitialize.
Return Values:
TRUE if the driver believes that the underlying hardware is hung,
FALSE otherwise.
---------------------------------------------------------------------------*/
{
return (Adapter->NeedReset);
}
VOID
HtDsuDisableInterrupt(
IN PHTDSU_ADAPTER Adapter
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
The MiniportDisableInterrupt request is used to disable the adapter
from generating any interrupts. Typically this is done by writing a
mask which disables the adapter from generating hardware interrupts.
If the underlying hardware does not support enabling and disabling
interrupts, the Miniport driver will have to register a MiniportISR
with the wrapper, and the Miniport driver will have to acknowledge
and save the interrupt information from within the interrupt service
routine.
This routine may be called any time interrupts are enabled. If the
underlying hardware is required to be in a certain state for this
routine to execute correctly, the Miniport driver must encapsulate
all portions of the driver which violate the state and which may be
called when interrupts are enabled, with a function and call the
function through the NdisMSynchronizeWithInterrupt service.
Interrupts will be in any state when called.
Parameters:
MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes
during MiniportInitialize.
Return Values:
None.
---------------------------------------------------------------------------*/
{
DBG_FUNC("HtDsuDisableInterrupt")
/*
// Save the current interrupt status on the card.
*/
USHORT InterruptStatus = CardGetInterrupt(Adapter);
// DBG_ENTER(Adapter);
/*
// Disable the interrupt at the card after saving the current state
// of the InterruptStatus register -- which will be reset by the clear
// interrupt command.
*/
Adapter->InterruptStatusFlag |= InterruptStatus;
CardClearInterrupt(Adapter);
CardDisableInterrupt(Adapter);
DBG_NOTICE(Adapter, ("IntrStatus=%Xh LineStatus=%Xh\n",
InterruptStatus,
READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1)
));
// DBG_LEAVE(Adapter);
}
VOID
HtDsuEnableInterrupt(
IN PHTDSU_ADAPTER Adapter
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
The MiniportEnableInterrupt request is used to enable the adapter for
generating any interrupts. Typically this is done by writing a mask
which will reenable adapter interrupts.
If the underlying hardware does not support enabling and disabling
interrupts, the Miniport driver will have to register a MiniportISR
with the wrapper, and the Miniport driver will have to acknowledge
and save the interrupt information from within the interrupt service
routine.
Interrupts will be in any state when called.
Parameters:
MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes
during MiniportInitialize.
Return Values:
None.
---------------------------------------------------------------------------*/
{
DBG_FUNC("HtDsuEnableInterrupt")
/*
// Save the current interrupt status on the card.
*/
USHORT InterruptStatus = CardGetInterrupt(Adapter);
// DBG_ENTER(Adapter);
CardEnableInterrupt(Adapter);
DBG_NOTICE(Adapter, ("IntrStatus=%Xh LineStatus=%Xh\n",
InterruptStatus,
READ_REGISTER_USHORT(&Adapter->AdapterRam->StatusLine1)
));
// DBG_LEAVE(Adapter);
}
VOID
HtDsuISR(
OUT PBOOLEAN InterruptRecognized,
OUT PBOOLEAN QueueMiniportHandleInterrupt,
IN PHTDSU_ADAPTER Adapter
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
The MiniportISR request is called if the adapter generates an
interrupt when there is an outstanding call to MiniportInitialize
or to MiniportReconfigure, if the Miniport driver supports sharing
its interrupt line with another adapter, or if the Miniport driver
specifies that the routine must be called for every interrupt (See
NdisMRegisterInterrupt's RequestIsr and SharedInterrupt parameters).
This routine runs immediately after an interrupt, at very high priority,
and is subject to all the limitations of the interrupt service routine
in the NDIS 3.0 specification. The driver should do as little work as
possible in this routine. It should return TRUE in the parameter
InterruptRecognized if it recognizes the interrupt as belonging to its
adapter, or FALSE otherwise. It should return TRUE in the parameter
QueueMiniportHandleInterrupt if it needs a call to MiniportHandleInterrupt
at a lower priority to complete the handling of the interrupt, or FALSE
otherwise.
Note that a Dpc will not be queued if the Miniport is currently executing
in any of the following routines: MiniportHalt, MiniportInitialize,
MiniportReconfigure.
Parameters:
InterruptRecognized _ If the Miniport is sharing an interrupt line, it
should set this parameter to TRUE if the Miniport
driver recognizes that the interrupt came from the
adapter it is supporting.
QueueMiniportHandleInterrupt _ If the Miniport driver is sharing an
interrupt line, it sets this parameter to
TRUE if the driver needs to have
MiniportHandleInterrupt called.
MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes
during MiniportInitialize.
Return Values:
None.
---------------------------------------------------------------------------*/
{
DBG_FUNC("HtDsuISR")
/*
// Save the current interrupt status on the card.
*/
USHORT InterruptStatus;
DBG_ENTER(Adapter);
/*
// This routine should never be called after initialization since we
// support the Enable/Disable Interrupt routines.
*/
if (InterruptStatus = CardGetInterrupt(Adapter))
{
/*
// The adapter prevents the failure case where additional status
// bits could be set between the time we read the InterruptStatus
// and it is reset by the clear interrupt command...
*/
CardClearInterrupt(Adapter);
Adapter->InterruptStatusFlag |= InterruptStatus;
/*
// The card generated an interrupt, we need to service it only if we are
// interested in it. In either case it must be dismissed from the card.
*/
*InterruptRecognized = TRUE;
*QueueMiniportHandleInterrupt = TRUE;
}
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;
UINT TimeOut;
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;
/*
// CAVEAT: Normally you don't want to stall execution in your
// DPC because locks are held and no other threads will run.
// However, I have seen some hardware/firmware anomallies
// on the answering side where we get here before the signal
// is established, so I double check here by waiting up to 100MS.
*/
TimeOut = 0;
while (!CardStatusRinging(Adapter, HTDSU_CMD_LINE1) ||
CardStatusNoSignal(Adapter, HTDSU_CMD_LINE1))
{
if (TimeOut++ > 1000)
{
DBG_ERROR(Adapter,("Timeout waiting for SIGNAL on line 1\n"));
break;
}
else
{
NdisStallExecution(_100_MICROSECONDS);
}
}
if (TimeOut != 0)
{
DBG_WARNING(Adapter, ("Ring1 signal delay=%d*100us\n", TimeOut));
}
/*
// Make sure the ring is still asserted or it may
// just be noise from the cable being unplugged.
*/
if (CardStatusRinging(Adapter, HTDSU_CMD_LINE1))
{
Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE1);
HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_RINGING);
}
else
{
DBG_WARNING(Adapter, ("Ring1 lost - 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;
TimeOut = 0;
while (!CardStatusRinging(Adapter, HTDSU_CMD_LINE2) ||
CardStatusNoSignal(Adapter, HTDSU_CMD_LINE2))
{
if (TimeOut++ > 100)
{
DBG_ERROR(Adapter,("Timeout waiting for SIGNAL on line 2\n"));
break;
}
else
{
NdisStallExecution(_100_MICROSECONDS);
}
}
if (TimeOut != 0)
{
DBG_WARNING(Adapter, ("Ring2 signal delay=%d*100us\n", TimeOut));
}
if (CardStatusRinging(Adapter, HTDSU_CMD_LINE2))
{
Link = GET_LINK_FROM_CARDLINE(Adapter, HTDSU_CMD_LINE2);
HtTapiLineDevStateHandler(Adapter, Link, LINEDEVSTATE_RINGING);
}
else
{
DBG_WARNING(Adapter, ("Ring2 lost - 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;
/*
// CAVEAT: Normally you don't want to stall execution in your
// DPC because locks are held and no other threads will run.
// However, I have seen some hardware/firmware anomallies
// on the calling side where we get here before the carrier
// is established, so I double check here by waiting up to 100MS.
*/
TimeOut = 0;
while (!CardStatusCarrierDetect(Adapter, HTDSU_CMD_LINE1) ||
!CardStatusOnLine(Adapter, HTDSU_CMD_LINE1))
{
if (TimeOut++ > 1000)
{
DBG_ERROR(Adapter,("Timeout waiting for CARRIER/LINE 1\n"));
break;
}
else
{
NdisStallExecution(_100_MICROSECONDS);
}
}
if (TimeOut != 0)
{
DBG_WARNING(Adapter, ("Connect1 carrier delay=%d*100us\n", TimeOut));
}
/*
// 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;
TimeOut = 0;
while (!CardStatusCarrierDetect(Adapter, HTDSU_CMD_LINE2) ||
!CardStatusOnLine(Adapter, HTDSU_CMD_LINE2))
{
if (TimeOut++ > 1000)
{
DBG_ERROR(Adapter,("Timeout waiting for CARRIER/LINE 2\n"));
break;
}
else
{
NdisStallExecution(_100_MICROSECONDS);
}
}
if (TimeOut != 0)
{
DBG_WARNING(Adapter, ("Connect2 carrier delay=%d*100us\n", TimeOut));
}
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);
}
