nic.h File Reference

#include <ndis.h>
#include "e1000hw.h"

Include dependency graph for nic.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_E1000_ADAPTER

Macros
#define	E1000_TAG   '001e'
#define	MAXIMUM_FRAME_SIZE   1522
#define	RECEIVE_BUFFER_SIZE   2048
#define	DRIVER_VERSION   1
#define	DEFAULT_INTERRUPT_MASK   (E1000_IMS_LSC | E1000_IMS_TXDW | E1000_IMS_TXQE | E1000_IMS_RXDMT0 | E1000_IMS_RXT0 | E1000_IMS_TXD_LOW)

Typedefs
typedef struct _E1000_ADAPTER	E1000_ADAPTER
typedef struct _E1000_ADAPTER *	PE1000_ADAPTER

Functions
BOOLEAN NTAPI	NICRecognizeHardware (IN PE1000_ADAPTER Adapter)
NDIS_STATUS NTAPI	NICInitializeAdapterResources (IN PE1000_ADAPTER Adapter, IN PNDIS_RESOURCE_LIST ResourceList)
NDIS_STATUS NTAPI	NICAllocateIoResources (IN PE1000_ADAPTER Adapter)
NDIS_STATUS NTAPI	NICRegisterInterrupts (IN PE1000_ADAPTER Adapter)
NDIS_STATUS NTAPI	NICUnregisterInterrupts (IN PE1000_ADAPTER Adapter)
NDIS_STATUS NTAPI	NICReleaseIoResources (IN PE1000_ADAPTER Adapter)
NDIS_STATUS NTAPI	NICPowerOn (IN PE1000_ADAPTER Adapter)
NDIS_STATUS NTAPI	NICSoftReset (IN PE1000_ADAPTER Adapter)
NDIS_STATUS NTAPI	NICEnableTxRx (IN PE1000_ADAPTER Adapter)
NDIS_STATUS NTAPI	NICDisableTxRx (IN PE1000_ADAPTER Adapter)
NDIS_STATUS NTAPI	NICGetPermanentMacAddress (IN PE1000_ADAPTER Adapter, OUT PUCHAR MacAddress)
NDIS_STATUS NTAPI	NICUpdateMulticastList (IN PE1000_ADAPTER Adapter)
NDIS_STATUS NTAPI	NICApplyPacketFilter (IN PE1000_ADAPTER Adapter)
VOID NTAPI	NICUpdateLinkStatus (IN PE1000_ADAPTER Adapter)
NDIS_STATUS NTAPI	MiniportSend (_In_ NDIS_HANDLE MiniportAdapterContext, _In_ PNDIS_PACKET Packet, _In_ UINT Flags)
NDIS_STATUS NTAPI	MiniportSetInformation (IN NDIS_HANDLE MiniportAdapterContext, IN NDIS_OID Oid, IN PVOID InformationBuffer, IN ULONG InformationBufferLength, OUT PULONG BytesRead, OUT PULONG BytesNeeded)
NDIS_STATUS NTAPI	MiniportQueryInformation (IN NDIS_HANDLE MiniportAdapterContext, IN NDIS_OID Oid, IN PVOID InformationBuffer, IN ULONG InformationBufferLength, OUT PULONG BytesWritten, OUT PULONG BytesNeeded)
VOID NTAPI	MiniportISR (OUT PBOOLEAN InterruptRecognized, OUT PBOOLEAN QueueMiniportHandleInterrupt, IN NDIS_HANDLE MiniportAdapterContext)
VOID NTAPI	MiniportHandleInterrupt (IN NDIS_HANDLE MiniportAdapterContext)
FORCEINLINE VOID	E1000ReadUlong (_In_ PE1000_ADAPTER Adapter, _In_ ULONG Address, _Out_ PULONG Value)
FORCEINLINE VOID	E1000WriteUlong (_In_ PE1000_ADAPTER Adapter, _In_ ULONG Address, _In_ ULONG Value)
FORCEINLINE VOID	E1000WriteIoUlong (_In_ PE1000_ADAPTER Adapter, _In_ ULONG Address, _In_ ULONG Value)
FORCEINLINE VOID	NICApplyInterruptMask (_In_ PE1000_ADAPTER Adapter)
FORCEINLINE VOID	NICDisableInterrupts (_In_ PE1000_ADAPTER Adapter)

Macro Definition Documentation

DEFAULT_INTERRUPT_MASK

#define DEFAULT_INTERRUPT_MASK   (E1000_IMS_LSC | E1000_IMS_TXDW | E1000_IMS_TXQE | E1000_IMS_RXDMT0 | E1000_IMS_RXT0 | E1000_IMS_TXD_LOW)

Definition at line 24 of file nic.h.

DRIVER_VERSION

#define DRIVER_VERSION   1

Definition at line 22 of file nic.h.

E1000_TAG

#define E1000_TAG   '001e'

Definition at line 17 of file nic.h.

MAXIMUM_FRAME_SIZE

#define MAXIMUM_FRAME_SIZE   1522

Definition at line 19 of file nic.h.

RECEIVE_BUFFER_SIZE

#define RECEIVE_BUFFER_SIZE   2048

Definition at line 20 of file nic.h.

Typedef Documentation

E1000_ADAPTER

typedef struct _E1000_ADAPTER E1000_ADAPTER

PE1000_ADAPTER

typedef struct _E1000_ADAPTER * PE1000_ADAPTER

Function Documentation

E1000ReadUlong()

FORCEINLINE VOID E1000ReadUlong	(	_In_ PE1000_ADAPTER	Adapter,
		_In_ ULONG	Address,
		_Out_ PULONG	Value
	)

Definition at line 209 of file nic.h.

{
    NdisReadRegisterUlong((PULONG)(Adapter->IoBase + Address), Value);
}

Referenced by E1000ReadEeprom(), MiniportHandleInterrupt(), MiniportISR(), NICApplyPacketFilter(), NICDisableTxRx(), NICSoftReset(), and NICUpdateLinkStatus().

E1000WriteIoUlong()

FORCEINLINE VOID E1000WriteIoUlong	(	_In_ PE1000_ADAPTER	Adapter,
		_In_ ULONG	Address,
		_In_ ULONG	Value
	)

Definition at line 229 of file nic.h.

{
    volatile ULONG Dummy;
 
    NdisRawWritePortUlong((PULONG)(Adapter->IoPort), Address);
    NdisReadRegisterUlong(Adapter->IoBase + E1000_REG_STATUS, &Dummy);
    NdisRawWritePortUlong((PULONG)(Adapter->IoPort + 4), Value);
}

Referenced by NICSoftReset().

E1000WriteUlong()

FORCEINLINE VOID E1000WriteUlong	(	_In_ PE1000_ADAPTER	Adapter,
		_In_ ULONG	Address,
		_In_ ULONG	Value
	)

Definition at line 219 of file nic.h.

{
    NdisWriteRegisterUlong((PULONG)(Adapter->IoBase + Address), Value);
}

Referenced by E1000ReadEeprom(), MiniportHandleInterrupt(), NICApplyInterruptMask(), NICApplyPacketFilter(), NICDisableInterrupts(), NICDisableTxRx(), NICEnableTxRx(), NICReleaseIoResources(), NICSoftReset(), NICTransmitPacket(), and NICUpdateMulticastList().

MiniportHandleInterrupt()

VOID NTAPI MiniportHandleInterrupt

(

IN NDIS_HANDLE

MiniportAdapterContext

)

Definition at line 46 of file interrupt.c.

{
    ULONG InterruptPending;
    PE1000_ADAPTER Adapter = (PE1000_ADAPTER)MiniportAdapterContext;
    volatile PE1000_TRANSMIT_DESCRIPTOR TransmitDescriptor;
 
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    InterruptPending = _InterlockedExchange(&Adapter->InterruptPending, 0);
 
 
    /* Link State Changed */
    if (InterruptPending & E1000_IMS_LSC)
    {
        ULONG Status;
 
        InterruptPending &= ~E1000_IMS_LSC;
        NDIS_DbgPrint(MAX_TRACE, ("Link status changed!.\n"));
 
        NICUpdateLinkStatus(Adapter);
 
        Status = Adapter->MediaState == NdisMediaStateConnected ? NDIS_STATUS_MEDIA_CONNECT : NDIS_STATUS_MEDIA_DISCONNECT;
 
        NdisMIndicateStatus(Adapter->AdapterHandle, Status, NULL, 0);
        NdisMIndicateStatusComplete(Adapter->AdapterHandle);
    }
 
    /* Handling receive interrupts */
    if (InterruptPending & (E1000_IMS_RXDMT0 | E1000_IMS_RXT0))
    {
        volatile PE1000_RECEIVE_DESCRIPTOR ReceiveDescriptor;
        PETH_HEADER EthHeader;
        ULONG BufferOffset;
        BOOLEAN bGotAny = FALSE;
        ULONG RxDescHead, RxDescTail, CurrRxDesc;
 
        /* Clear out these interrupts */
        InterruptPending &= ~(E1000_IMS_RXDMT0 | E1000_IMS_RXT0);
 
        E1000ReadUlong(Adapter, E1000_REG_RDH, &RxDescHead);
        E1000ReadUlong(Adapter, E1000_REG_RDT, &RxDescTail);
 
        while (((RxDescTail + 1) % NUM_RECEIVE_DESCRIPTORS) != RxDescHead)
        {
            CurrRxDesc = (RxDescTail + 1) % NUM_RECEIVE_DESCRIPTORS;
            BufferOffset = CurrRxDesc * Adapter->ReceiveBufferEntrySize;
            ReceiveDescriptor = Adapter->ReceiveDescriptors + CurrRxDesc;
 
            /* Check if the hardware have released this descriptor (DD - Descriptor Done) */
            if (!(ReceiveDescriptor->Status & E1000_RDESC_STATUS_DD))
            {
                /* No need to check descriptors after the first unfinished one */
                break;
            }
 
            /* Ignoring these flags for now */
            ReceiveDescriptor->Status &= ~(E1000_RDESC_STATUS_IXSM | E1000_RDESC_STATUS_PIF);
 
            if (ReceiveDescriptor->Status != (E1000_RDESC_STATUS_EOP | E1000_RDESC_STATUS_DD))
            {
                NDIS_DbgPrint(MIN_TRACE, ("Unrecognized ReceiveDescriptor status flag: %u\n", ReceiveDescriptor->Status));
            }
 
            /* Make sure the receive indications are enabled */
            if (!Adapter->PacketFilter)
            {
                goto NextReceiveDescriptor;
            }
 
            if (ReceiveDescriptor->Length != 0 && ReceiveDescriptor->Address != 0)
            {
                EthHeader = (PETH_HEADER)(Adapter->ReceiveBuffer + BufferOffset);
 
                NdisMEthIndicateReceive(Adapter->AdapterHandle,
                                        NULL,
                                        (PCHAR)EthHeader,
                                        sizeof(ETH_HEADER),
                                        (PCHAR)(EthHeader + 1),
                                        ReceiveDescriptor->Length - sizeof(ETH_HEADER),
                                        ReceiveDescriptor->Length - sizeof(ETH_HEADER));
 
                bGotAny = TRUE;
            }
            else
            {
                NDIS_DbgPrint(MIN_TRACE, ("Got a NULL descriptor"));
            }
 
NextReceiveDescriptor:
            /* Give the descriptor back */
            ReceiveDescriptor->Status = 0;
 
            RxDescTail = CurrRxDesc;
        }
 
        if (bGotAny)
        {
            /* Write back new tail value */
            E1000WriteUlong(Adapter, E1000_REG_RDT, RxDescTail);
 
            NDIS_DbgPrint(MAX_TRACE, ("Rx done (RDH: %u, RDT: %u)\n", RxDescHead, RxDescTail));
 
            NdisMEthIndicateReceiveComplete(Adapter->AdapterHandle);
        }
    }
 
    /* Handling transmit interrupts */
    if (InterruptPending & (E1000_IMS_TXD_LOW | E1000_IMS_TXDW | E1000_IMS_TXQE))
    {
        PNDIS_PACKET AckPackets[40] = {0};
        ULONG NumPackets = 0, i;
 
        /* Clear out these interrupts */
        InterruptPending &= ~(E1000_IMS_TXD_LOW | E1000_IMS_TXDW | E1000_IMS_TXQE);
 
        while ((Adapter->TxFull || Adapter->LastTxDesc != Adapter->CurrentTxDesc) && NumPackets < ARRAYSIZE(AckPackets))
        {
            TransmitDescriptor = Adapter->TransmitDescriptors + Adapter->LastTxDesc;
 
            if (TransmitDescriptor->Status & E1000_TDESC_STATUS_DD)
            {
                if (Adapter->TransmitPackets[Adapter->LastTxDesc])
                {
                    AckPackets[NumPackets++] = Adapter->TransmitPackets[Adapter->LastTxDesc];
                    Adapter->TransmitPackets[Adapter->LastTxDesc] = NULL;
                    TransmitDescriptor->Status = 0;
                }
 
                Adapter->LastTxDesc = (Adapter->LastTxDesc + 1) % NUM_TRANSMIT_DESCRIPTORS;
                Adapter->TxFull = FALSE;
            }
            else
            {
                break;
            }
        }
 
        if (NumPackets)
        {
            NDIS_DbgPrint(MAX_TRACE, ("Tx: (TDH: %u, TDT: %u)\n", Adapter->CurrentTxDesc, Adapter->LastTxDesc));
            NDIS_DbgPrint(MAX_TRACE, ("Tx Done: %u packets to ack\n", NumPackets));
 
            for (i = 0; i < NumPackets; ++i)
            {
                NdisMSendComplete(Adapter->AdapterHandle, AckPackets[i], NDIS_STATUS_SUCCESS);
            }
        }
    }
 
    ASSERT(InterruptPending == 0);
}

MiniportISR()

VOID NTAPI MiniportISR	(	OUT PBOOLEAN	InterruptRecognized,
		OUT PBOOLEAN	QueueMiniportHandleInterrupt,
		IN NDIS_HANDLE	MiniportAdapterContext
	)

Definition at line 16 of file interrupt.c.

{
    ULONG Value;
    PE1000_ADAPTER Adapter = (PE1000_ADAPTER)MiniportAdapterContext;
 
    /* Reading the interrupt acknowledges them */
    E1000ReadUlong(Adapter, E1000_REG_ICR, &Value);
 
    Value &= Adapter->InterruptMask;
    _InterlockedOr(&Adapter->InterruptPending, Value);
 
    if (Value)
    {
        *InterruptRecognized = TRUE;
        /* Mark the events pending service */
        *QueueMiniportHandleInterrupt = TRUE;
    }
    else
    {
        /* This is not ours. */
        *InterruptRecognized = FALSE;
        *QueueMiniportHandleInterrupt = FALSE;
    }
}

MiniportQueryInformation()

NDIS_STATUS NTAPI MiniportQueryInformation	(	IN NDIS_HANDLE	MiniportAdapterContext,
		IN NDIS_OID	Oid,
		IN PVOID	InformationBuffer,
		IN ULONG	InformationBufferLength,
		OUT PULONG	BytesWritten,
		OUT PULONG	BytesNeeded
	)

Definition at line 73 of file info.c.

{
    PE1000_ADAPTER Adapter = (PE1000_ADAPTER)MiniportAdapterContext;
    ULONG copyLength;
    PVOID copySource;
    NDIS_STATUS status;
    union _GENERIC_INFORMATION
    {
        USHORT Ushort;
        ULONG Ulong;
        ULONG64 Ulong64;
        NDIS_MEDIUM Medium;
        NDIS_PNP_CAPABILITIES PmCapabilities;
    } GenericInfo;
 
    status = NDIS_STATUS_SUCCESS;
    copySource = &GenericInfo;
    copyLength = sizeof(ULONG);
 
    switch (Oid)
    {
    case OID_GEN_SUPPORTED_LIST:
        copySource = (PVOID)&SupportedOidList;
        copyLength = sizeof(SupportedOidList);
        break;
 
    case OID_GEN_CURRENT_PACKET_FILTER:
        GenericInfo.Ulong = Adapter->PacketFilter;
        break;
 
    case OID_GEN_HARDWARE_STATUS:
        UNIMPLEMENTED_DBGBREAK();
        GenericInfo.Ulong = (ULONG)NdisHardwareStatusReady; //FIXME
        break;
 
    case OID_GEN_MEDIA_SUPPORTED:
    case OID_GEN_MEDIA_IN_USE:
    {
        GenericInfo.Medium = NdisMedium802_3;
        copyLength = sizeof(NDIS_MEDIUM);
        break;
    }
 
    case OID_GEN_RECEIVE_BLOCK_SIZE:
    case OID_GEN_TRANSMIT_BLOCK_SIZE:
    case OID_GEN_CURRENT_LOOKAHEAD:
    case OID_GEN_MAXIMUM_LOOKAHEAD:
    case OID_GEN_MAXIMUM_FRAME_SIZE:
        GenericInfo.Ulong = MAXIMUM_FRAME_SIZE - sizeof(ETH_HEADER);
        break;
 
    case OID_802_3_MULTICAST_LIST:
        copySource = Adapter->MulticastList;
        copyLength = Adapter->MulticastListSize * IEEE_802_ADDR_LENGTH;
        break;
 
    case OID_802_3_MAXIMUM_LIST_SIZE:
        GenericInfo.Ulong = MAXIMUM_MULTICAST_ADDRESSES;
        break;
 
    case OID_GEN_LINK_SPEED:
        GenericInfo.Ulong = Adapter->LinkSpeedMbps * 10000;
        break;
 
    case OID_GEN_TRANSMIT_BUFFER_SPACE:
        GenericInfo.Ulong = MAXIMUM_FRAME_SIZE;
        break;
 
    case OID_GEN_RECEIVE_BUFFER_SPACE:
        GenericInfo.Ulong = RECEIVE_BUFFER_SIZE;
        break;
 
    case OID_GEN_VENDOR_ID:
        /* The 3 bytes of the MAC address is the vendor ID */
        GenericInfo.Ulong = 0;
        GenericInfo.Ulong |= (Adapter->PermanentMacAddress[0] << 16);
        GenericInfo.Ulong |= (Adapter->PermanentMacAddress[1] << 8);
        GenericInfo.Ulong |= (Adapter->PermanentMacAddress[2] & 0xFF);
        break;
 
    case OID_GEN_VENDOR_DESCRIPTION:
    {
        static UCHAR vendorDesc[] = "ReactOS Team";
        copySource = vendorDesc;
        copyLength = sizeof(vendorDesc);
        break;
    }
 
    case OID_GEN_VENDOR_DRIVER_VERSION:
        GenericInfo.Ulong = DRIVER_VERSION;
        break;
 
    case OID_GEN_DRIVER_VERSION:
    {
        copyLength = sizeof(USHORT);
        GenericInfo.Ushort = (NDIS_MINIPORT_MAJOR_VERSION << 8) + NDIS_MINIPORT_MINOR_VERSION;
        break;
    }
 
    case OID_GEN_MAXIMUM_TOTAL_SIZE:
        GenericInfo.Ulong = MAXIMUM_FRAME_SIZE;
        break;
 
    case OID_GEN_MAXIMUM_SEND_PACKETS:
        GenericInfo.Ulong = 1;
        break;
 
    case OID_GEN_MAC_OPTIONS:
        GenericInfo.Ulong = NDIS_MAC_OPTION_RECEIVE_SERIALIZED |
            NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA |
            NDIS_MAC_OPTION_TRANSFERS_NOT_PEND |
            NDIS_MAC_OPTION_NO_LOOPBACK;
        break;
 
    case OID_GEN_MEDIA_CONNECT_STATUS:
        GenericInfo.Ulong = Adapter->MediaState;
        break;
 
    case OID_802_3_CURRENT_ADDRESS:
        copySource = Adapter->MulticastList[0].MacAddress;
        copyLength = IEEE_802_ADDR_LENGTH;
        break;
 
    case OID_802_3_PERMANENT_ADDRESS:
        copySource = Adapter->PermanentMacAddress;
        copyLength = IEEE_802_ADDR_LENGTH;
        break;
 
    case OID_GEN_XMIT_OK:
    case OID_GEN_RCV_OK:
    case OID_GEN_XMIT_ERROR:
    case OID_GEN_RCV_ERROR:
    case OID_GEN_RCV_NO_BUFFER:
    {
        GenericInfo.Ulong64 = NICQueryStatisticCounter(Adapter, Oid);
 
        *BytesNeeded = sizeof(ULONG64);
        if (InformationBufferLength >= sizeof(ULONG64))
        {
            *BytesWritten = sizeof(ULONG64);
            NdisMoveMemory(InformationBuffer, copySource, sizeof(ULONG64));
        }
        else if (InformationBufferLength >= sizeof(ULONG))
        {
            *BytesWritten = sizeof(ULONG);
            NdisMoveMemory(InformationBuffer, copySource, sizeof(ULONG));
        }
        else
        {
            *BytesWritten = 0;
            return NDIS_STATUS_BUFFER_TOO_SHORT;
        }
        return NDIS_STATUS_SUCCESS;
    }
 
    case OID_PNP_CAPABILITIES:
    {
        copyLength = sizeof(NDIS_PNP_CAPABILITIES);
 
        status = NICFillPowerManagementCapabilities(Adapter, &GenericInfo.PmCapabilities);
        break;
    }
 
    default:
        NDIS_DbgPrint(MIN_TRACE, ("Unknown OID 0x%x(%s)\n", Oid, Oid2Str(Oid)));
        status = NDIS_STATUS_NOT_SUPPORTED;
        break;
    }
 
    if (status == NDIS_STATUS_SUCCESS)
    {
        if (copyLength > InformationBufferLength)
        {
            *BytesNeeded = copyLength;
            *BytesWritten = 0;
            status = NDIS_STATUS_BUFFER_TOO_SHORT;
        }
        else
        {
            NdisMoveMemory(InformationBuffer, copySource, copyLength);
            *BytesWritten = copyLength;
            *BytesNeeded = copyLength;
        }
    }
    else
    {
        *BytesWritten = 0;
        *BytesNeeded = 0;
    }
 
    NDIS_DbgPrint(MAX_TRACE, ("Query OID 0x%x(%s): Completed with status 0x%x (%d, %d)\n",
                              Oid, Oid2Str(Oid), status, *BytesWritten, *BytesNeeded));
    return status;
}

MiniportSend()

NDIS_STATUS NTAPI MiniportSend	(	_In_ NDIS_HANDLE	MiniportAdapterContext,
		_In_ PNDIS_PACKET	Packet,
		_In_ UINT	Flags
	)

Definition at line 49 of file send.c.

{
    PE1000_ADAPTER Adapter = (PE1000_ADAPTER)MiniportAdapterContext;
    PSCATTER_GATHER_LIST sgList;
    ULONG TransmitLength;
    PHYSICAL_ADDRESS TransmitBuffer;
    NDIS_STATUS Status;
 
    sgList = NDIS_PER_PACKET_INFO_FROM_PACKET(Packet, ScatterGatherListPacketInfo);
 
    ASSERT(sgList != NULL);
    ASSERT(sgList->NumberOfElements == 1);
    ASSERT((sgList->Elements[0].Address.LowPart & 3) == 0);
    ASSERT(sgList->Elements[0].Length <= MAXIMUM_FRAME_SIZE);
 
    if (Adapter->TxFull)
    {
        NDIS_DbgPrint(MIN_TRACE, ("All TX descriptors are full\n"));
        return NDIS_STATUS_RESOURCES;
    }
 
    TransmitLength = sgList->Elements[0].Length;
    TransmitBuffer = sgList->Elements[0].Address;
    Adapter->TransmitPackets[Adapter->CurrentTxDesc] = Packet;
 
    Status = NICTransmitPacket(Adapter, TransmitBuffer, TransmitLength);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        NDIS_DbgPrint(MIN_TRACE, ("Transmit packet failed\n"));
        return Status;
    }
 
    return NDIS_STATUS_PENDING;
}

Referenced by DriverEntry().

MiniportSetInformation()

NDIS_STATUS NTAPI MiniportSetInformation	(	IN NDIS_HANDLE	MiniportAdapterContext,
		IN NDIS_OID	Oid,
		IN PVOID	InformationBuffer,
		IN ULONG	InformationBufferLength,
		OUT PULONG	BytesRead,
		OUT PULONG	BytesNeeded
	)

Definition at line 276 of file info.c.

{
    PE1000_ADAPTER Adapter = (PE1000_ADAPTER)MiniportAdapterContext;
    ULONG genericUlong;
    NDIS_STATUS status;
 
    status = NDIS_STATUS_SUCCESS;
 
    switch (Oid)
    {
    case OID_GEN_CURRENT_PACKET_FILTER:
        if (InformationBufferLength < sizeof(ULONG))
        {
            *BytesRead = 0;
            *BytesNeeded = sizeof(ULONG);
            status = NDIS_STATUS_INVALID_LENGTH;
            break;
        }
 
        NdisMoveMemory(&genericUlong, InformationBuffer, sizeof(ULONG));
 
        if (genericUlong &
            ~(NDIS_PACKET_TYPE_DIRECTED |
              NDIS_PACKET_TYPE_MULTICAST |
              NDIS_PACKET_TYPE_ALL_MULTICAST |
              NDIS_PACKET_TYPE_BROADCAST |
              NDIS_PACKET_TYPE_PROMISCUOUS |
              NDIS_PACKET_TYPE_MAC_FRAME))
        {
            *BytesRead = sizeof(ULONG);
            *BytesNeeded = sizeof(ULONG);
            status = NDIS_STATUS_NOT_SUPPORTED;
            break;
        }
 
        if (Adapter->PacketFilter == genericUlong)
        {
            break;
        }
 
        Adapter->PacketFilter = genericUlong;
 
        status = NICApplyPacketFilter(Adapter);
        if (status != NDIS_STATUS_SUCCESS)
        {
            NDIS_DbgPrint(MIN_TRACE, ("Failed to apply new packet filter (0x%x)\n", status));
            break;
        }
 
        break;
 
    case OID_GEN_CURRENT_LOOKAHEAD:
        if (InformationBufferLength < sizeof(ULONG))
        {
            *BytesRead = 0;
            *BytesNeeded = sizeof(ULONG);
            status = NDIS_STATUS_INVALID_LENGTH;
            break;
        }
 
        NdisMoveMemory(&genericUlong, InformationBuffer, sizeof(ULONG));
 
        if (genericUlong > MAXIMUM_FRAME_SIZE - sizeof(ETH_HEADER))
        {
            status = NDIS_STATUS_INVALID_DATA;
        }
        else
        {
            // Ignore this...
        }
 
        break;
 
    case OID_802_3_MULTICAST_LIST:
        if (InformationBufferLength % IEEE_802_ADDR_LENGTH)
        {
            *BytesRead = 0;
            *BytesNeeded = InformationBufferLength + (InformationBufferLength % IEEE_802_ADDR_LENGTH);
            status = NDIS_STATUS_INVALID_LENGTH;
            break;
        }
 
        if (InformationBufferLength > sizeof(Adapter->MulticastList))
        {
            *BytesNeeded = sizeof(Adapter->MulticastList);
            *BytesRead = 0;
            status = NDIS_STATUS_MULTICAST_FULL;
            break;
        }
 
        NdisMoveMemory(Adapter->MulticastList, InformationBuffer, InformationBufferLength);
 
        Adapter->MulticastListSize = InformationBufferLength / IEEE_802_ADDR_LENGTH;
 
        NICUpdateMulticastList(Adapter);
        break;
 
    default:
        NDIS_DbgPrint(MIN_TRACE, ("Unknown OID 0x%x(%s)\n", Oid, Oid2Str(Oid)));
        status = NDIS_STATUS_NOT_SUPPORTED;
        *BytesRead = 0;
        *BytesNeeded = 0;
        break;
    }
 
    if (status == NDIS_STATUS_SUCCESS)
    {
        *BytesRead = InformationBufferLength;
        *BytesNeeded = 0;
    }
 
    return status;
}

NICAllocateIoResources()

NDIS_STATUS NTAPI NICAllocateIoResources

(

IN PE1000_ADAPTER

Adapter

)

Definition at line 309 of file hardware.c.

{
    NDIS_STATUS Status;
    ULONG AllocationSize;
    UINT n;
 
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    Status = NdisMRegisterIoPortRange((PVOID*)&Adapter->IoPort,
                                      Adapter->AdapterHandle,
                                      Adapter->IoPortAddress,
                                      Adapter->IoPortLength);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        NDIS_DbgPrint(MIN_TRACE, ("Unable to register IO port range (0x%x)\n", Status));
        return NDIS_STATUS_RESOURCES;
    }
 
    Status = NdisMMapIoSpace((PVOID*)&Adapter->IoBase,
                             Adapter->AdapterHandle,
                             Adapter->IoAddress,
                             Adapter->IoLength);
 
 
    NdisMAllocateSharedMemory(Adapter->AdapterHandle,
                              sizeof(E1000_TRANSMIT_DESCRIPTOR) * NUM_TRANSMIT_DESCRIPTORS,
                              FALSE,
                              (PVOID*)&Adapter->TransmitDescriptors,
                              &Adapter->TransmitDescriptorsPa);
    if (Adapter->TransmitDescriptors == NULL)
    {
        NDIS_DbgPrint(MIN_TRACE, ("Unable to allocate transmit descriptors\n"));
        return NDIS_STATUS_RESOURCES;
    }
 
    for (n = 0; n < NUM_TRANSMIT_DESCRIPTORS; ++n)
    {
        PE1000_TRANSMIT_DESCRIPTOR Descriptor = Adapter->TransmitDescriptors + n;
        Descriptor->Address = 0;
        Descriptor->Length = 0;
    }
 
    NdisMAllocateSharedMemory(Adapter->AdapterHandle,
                              sizeof(E1000_RECEIVE_DESCRIPTOR) * NUM_RECEIVE_DESCRIPTORS,
                              FALSE,
                              (PVOID*)&Adapter->ReceiveDescriptors,
                              &Adapter->ReceiveDescriptorsPa);
    if (Adapter->ReceiveDescriptors == NULL)
    {
        NDIS_DbgPrint(MIN_TRACE, ("Unable to allocate receive descriptors\n"));
        return NDIS_STATUS_RESOURCES;
    }
 
    AllocationSize = RcvBufAllocationSize(Adapter->ReceiveBufferType);
    ASSERT(Adapter->ReceiveBufferEntrySize == 0 || Adapter->ReceiveBufferEntrySize == AllocationSize);
    Adapter->ReceiveBufferEntrySize = AllocationSize;
 
    NdisMAllocateSharedMemory(Adapter->AdapterHandle,
                              Adapter->ReceiveBufferEntrySize * NUM_RECEIVE_DESCRIPTORS,
                              FALSE,
                              (PVOID*)&Adapter->ReceiveBuffer,
                              &Adapter->ReceiveBufferPa);
 
    if (Adapter->ReceiveBuffer == NULL)
    {
        NDIS_DbgPrint(MIN_TRACE, ("Unable to allocate receive buffer\n"));
        return NDIS_STATUS_RESOURCES;
    }
 
    for (n = 0; n < NUM_RECEIVE_DESCRIPTORS; ++n)
    {
        PE1000_RECEIVE_DESCRIPTOR Descriptor = Adapter->ReceiveDescriptors + n;
 
        RtlZeroMemory(Descriptor, sizeof(*Descriptor));
        Descriptor->Address = Adapter->ReceiveBufferPa.QuadPart + n * Adapter->ReceiveBufferEntrySize;
    }
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportInitialize().

NICApplyInterruptMask()

FORCEINLINE VOID NICApplyInterruptMask

(

_In_ PE1000_ADAPTER

Adapter

)

Definition at line 243 of file nic.h.

{
    E1000WriteUlong(Adapter, E1000_REG_IMS, Adapter->InterruptMask /*| 0x1F6DC*/);
}

Referenced by MiniportInitialize().

NICApplyPacketFilter()

NDIS_STATUS NTAPI NICApplyPacketFilter

(

IN PE1000_ADAPTER

Adapter

)

Definition at line 724 of file hardware.c.

{
    ULONG FilterMask;
 
    E1000ReadUlong(Adapter, E1000_REG_RCTL, &FilterMask);
 
    FilterMask &= ~E1000_RCTL_FILTER_BITS;
    FilterMask |= PacketFilterToMask(Adapter->PacketFilter);
    E1000WriteUlong(Adapter, E1000_REG_RCTL, FilterMask);
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportSetInformation().

NICDisableInterrupts()

FORCEINLINE VOID NICDisableInterrupts

(

_In_ PE1000_ADAPTER

Adapter

)

Definition at line 251 of file nic.h.

{
    E1000WriteUlong(Adapter, E1000_REG_IMC, ~0);
}

NICDisableTxRx()

NDIS_STATUS NTAPI NICDisableTxRx

(

IN PE1000_ADAPTER

Adapter

)

Definition at line 641 of file hardware.c.

{
    ULONG Value;
 
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    E1000ReadUlong(Adapter, E1000_REG_TCTL, &Value);
    Value &= ~E1000_TCTL_EN;
    E1000WriteUlong(Adapter, E1000_REG_TCTL, Value);
 
    E1000ReadUlong(Adapter, E1000_REG_RCTL, &Value);
    Value &= ~E1000_RCTL_EN;
    E1000WriteUlong(Adapter, E1000_REG_RCTL, Value);
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportHalt().

NICEnableTxRx()

NDIS_STATUS NTAPI NICEnableTxRx

(

IN PE1000_ADAPTER

Adapter

)

Definition at line 574 of file hardware.c.

{
    ULONG Value;
 
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
    NDIS_DbgPrint(MID_TRACE, ("Setting up transmit.\n"));
 
    /* Make sure the thing is disabled first. */
    E1000WriteUlong(Adapter, E1000_REG_TCTL, 0);
 
    /* Transmit descriptor ring buffer */
    E1000WriteUlong(Adapter, E1000_REG_TDBAH, Adapter->TransmitDescriptorsPa.HighPart);
    E1000WriteUlong(Adapter, E1000_REG_TDBAL, Adapter->TransmitDescriptorsPa.LowPart);
 
    /* Transmit descriptor buffer size */
    E1000WriteUlong(Adapter, E1000_REG_TDLEN, sizeof(E1000_TRANSMIT_DESCRIPTOR) * NUM_TRANSMIT_DESCRIPTORS);
 
    /* Transmit descriptor tail / head */
    E1000WriteUlong(Adapter, E1000_REG_TDH, 0);
    E1000WriteUlong(Adapter, E1000_REG_TDT, 0);
    Adapter->CurrentTxDesc = 0;
 
    /* Set up interrupt timers */
    E1000WriteUlong(Adapter, E1000_REG_TADV, 96); // value is in 1.024 of usec
    E1000WriteUlong(Adapter, E1000_REG_TIDV, 16);
 
    E1000WriteUlong(Adapter, E1000_REG_TCTL, E1000_TCTL_EN | E1000_TCTL_PSP);
 
    E1000WriteUlong(Adapter, E1000_REG_TIPG, E1000_TIPG_IPGT_DEF | E1000_TIPG_IPGR1_DEF | E1000_TIPG_IPGR2_DEF);
 
    NDIS_DbgPrint(MID_TRACE, ("Setting up receive.\n"));
 
    /* Make sure the thing is disabled first. */
    E1000WriteUlong(Adapter, E1000_REG_RCTL, 0);
 
    /* Receive descriptor ring buffer */
    E1000WriteUlong(Adapter, E1000_REG_RDBAH, Adapter->ReceiveDescriptorsPa.HighPart);
    E1000WriteUlong(Adapter, E1000_REG_RDBAL, Adapter->ReceiveDescriptorsPa.LowPart);
 
    /* Receive descriptor buffer size */
    E1000WriteUlong(Adapter, E1000_REG_RDLEN, sizeof(E1000_RECEIVE_DESCRIPTOR) * NUM_RECEIVE_DESCRIPTORS);
 
    /* Receive descriptor tail / head */
    E1000WriteUlong(Adapter, E1000_REG_RDH, 0);
    E1000WriteUlong(Adapter, E1000_REG_RDT, NUM_RECEIVE_DESCRIPTORS - 1);
 
    /* Set up interrupt timers */
    E1000WriteUlong(Adapter, E1000_REG_RADV, 96);
    E1000WriteUlong(Adapter, E1000_REG_RDTR, 16);
 
    /* Some defaults */
    Value = E1000_RCTL_SECRC | E1000_RCTL_EN;
 
    /* Receive buffer size */
    Value |= RcvBufRegisterMask(Adapter->ReceiveBufferType);
 
    /* Add our current packet filter */
    Value |= PacketFilterToMask(Adapter->PacketFilter);
 
    E1000WriteUlong(Adapter, E1000_REG_RCTL, Value);
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportInitialize().

NICGetPermanentMacAddress()

NDIS_STATUS NTAPI NICGetPermanentMacAddress	(	IN PE1000_ADAPTER	Adapter,
		OUT PUCHAR	MacAddress
	)

Definition at line 661 of file hardware.c.

{
    USHORT AddrWord;
    UINT n;
 
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    /* Should we read from RAL/RAH first? */
    for (n = 0; n < (IEEE_802_ADDR_LENGTH / 2); ++n)
    {
        if (!E1000ReadEeprom(Adapter, (UCHAR)n, &AddrWord))
            return NDIS_STATUS_FAILURE;
        Adapter->PermanentMacAddress[n * 2 + 0] = AddrWord & 0xff;
        Adapter->PermanentMacAddress[n * 2 + 1] = (AddrWord >> 8) & 0xff;
    }
 
#if 0
    NDIS_DbgPrint(MIN_TRACE, ("MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
                              Adapter->PermanentMacAddress[0],
                              Adapter->PermanentMacAddress[1],
                              Adapter->PermanentMacAddress[2],
                              Adapter->PermanentMacAddress[3],
                              Adapter->PermanentMacAddress[4],
                              Adapter->PermanentMacAddress[5]));
#endif
    return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportInitialize().

NICInitializeAdapterResources()

NDIS_STATUS NTAPI NICInitializeAdapterResources	(	IN PE1000_ADAPTER	Adapter,
		IN PNDIS_RESOURCE_LIST	ResourceList
	)

Definition at line 241 of file hardware.c.

{
    UINT n;
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    for (n = 0; n < ResourceList->Count; n++)
    {
        PCM_PARTIAL_RESOURCE_DESCRIPTOR ResourceDescriptor = ResourceList->PartialDescriptors + n;
 
        switch (ResourceDescriptor->Type)
        {
        case CmResourceTypePort:
            ASSERT(Adapter->IoPortAddress == 0);
            ASSERT(ResourceDescriptor->u.Port.Start.HighPart == 0);
 
            Adapter->IoPortAddress = ResourceDescriptor->u.Port.Start.LowPart;
            Adapter->IoPortLength = ResourceDescriptor->u.Port.Length;
 
            NDIS_DbgPrint(MID_TRACE, ("I/O port range is %p to %p\n",
                                      Adapter->IoPortAddress,
                                      Adapter->IoPortAddress + Adapter->IoPortLength));
            break;
        case CmResourceTypeInterrupt:
            ASSERT(Adapter->InterruptVector == 0);
            ASSERT(Adapter->InterruptLevel == 0);
 
            Adapter->InterruptVector = ResourceDescriptor->u.Interrupt.Vector;
            Adapter->InterruptLevel = ResourceDescriptor->u.Interrupt.Level;
            Adapter->InterruptShared = (ResourceDescriptor->ShareDisposition == CmResourceShareShared);
            Adapter->InterruptFlags = ResourceDescriptor->Flags;
 
            NDIS_DbgPrint(MID_TRACE, ("IRQ vector is %d\n", Adapter->InterruptVector));
            break;
        case CmResourceTypeMemory:
            /* Internal registers and memories (including PHY) */
            if (ResourceDescriptor->u.Memory.Length ==  (128 * 1024))
            {
                ASSERT(Adapter->IoAddress.LowPart == 0);
                ASSERT(ResourceDescriptor->u.Port.Start.HighPart == 0);
 
 
                Adapter->IoAddress.QuadPart = ResourceDescriptor->u.Memory.Start.QuadPart;
                Adapter->IoLength = ResourceDescriptor->u.Memory.Length;
                NDIS_DbgPrint(MID_TRACE, ("Memory range is %I64x to %I64x\n",
                                          Adapter->IoAddress.QuadPart,
                                          Adapter->IoAddress.QuadPart + Adapter->IoLength));
            }
            break;
 
        default:
            NDIS_DbgPrint(MIN_TRACE, ("Unrecognized resource type: 0x%x\n", ResourceDescriptor->Type));
            break;
        }
    }
 
    if (Adapter->IoAddress.QuadPart == 0 || Adapter->IoPortAddress == 0 || Adapter->InterruptVector == 0)
    {
        NDIS_DbgPrint(MIN_TRACE, ("Adapter didn't receive enough resources\n"));
        return NDIS_STATUS_RESOURCES;
    }
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportInitialize().

NICPowerOn()

NDIS_STATUS NTAPI NICPowerOn

(

IN PE1000_ADAPTER

Adapter

)

Definition at line 509 of file hardware.c.

{
    NDIS_STATUS Status;
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    Status = NICSoftReset(Adapter);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        return Status;
    }
 
    if (!E1000ValidateNvmChecksum(Adapter))
    {
        return NDIS_STATUS_INVALID_DATA;
    }
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportInitialize().

NICRecognizeHardware()

BOOLEAN NTAPI NICRecognizeHardware

(

IN PE1000_ADAPTER

Adapter

)

Definition at line 214 of file hardware.c.

{
    UINT n;
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    if (Adapter->VendorID != HW_VENDOR_INTEL)
    {
        NDIS_DbgPrint(MIN_TRACE, ("Unknown vendor: 0x%x\n", Adapter->VendorID));
        return FALSE;
    }
 
    for (n = 0; n < ARRAYSIZE(SupportedDevices); ++n)
    {
        if (SupportedDevices[n] == Adapter->DeviceID)
        {
            return TRUE;
        }
    }
 
    NDIS_DbgPrint(MIN_TRACE, ("Unknown device: 0x%x\n", Adapter->DeviceID));
 
    return FALSE;
}

Referenced by MiniportInitialize().

NICRegisterInterrupts()

NDIS_STATUS NTAPI NICRegisterInterrupts

(

IN PE1000_ADAPTER

Adapter

)

Definition at line 392 of file hardware.c.

{
    NDIS_STATUS Status;
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    Status = NdisMRegisterInterrupt(&Adapter->Interrupt,
                                    Adapter->AdapterHandle,
                                    Adapter->InterruptVector,
                                    Adapter->InterruptLevel,
                                    TRUE, // We always want ISR calls
                                    Adapter->InterruptShared,
                                    (Adapter->InterruptFlags & CM_RESOURCE_INTERRUPT_LATCHED) ?
                                    NdisInterruptLatched : NdisInterruptLevelSensitive);
 
    if (Status == NDIS_STATUS_SUCCESS)
    {
        Adapter->InterruptRegistered = TRUE;
    }
 
    return Status;
}

Referenced by MiniportInitialize().

NICReleaseIoResources()

NDIS_STATUS NTAPI NICReleaseIoResources

(

IN PE1000_ADAPTER

Adapter

)

Definition at line 433 of file hardware.c.

{
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    if (Adapter->ReceiveDescriptors != NULL)
    {
        /* Disassociate our shared buffer before freeing it to avoid NIC-induced memory corruption */
        if (Adapter->IoBase)
        {
            E1000WriteUlong(Adapter, E1000_REG_RDH, 0);
            E1000WriteUlong(Adapter, E1000_REG_RDT, 0);
        }
 
        NdisMFreeSharedMemory(Adapter->AdapterHandle,
                              sizeof(E1000_RECEIVE_DESCRIPTOR) * NUM_RECEIVE_DESCRIPTORS,
                              FALSE,
                              Adapter->ReceiveDescriptors,
                              Adapter->ReceiveDescriptorsPa);
 
        Adapter->ReceiveDescriptors = NULL;
    }
 
    if (Adapter->ReceiveBuffer != NULL)
    {
        NdisMFreeSharedMemory(Adapter->AdapterHandle,
                              Adapter->ReceiveBufferEntrySize * NUM_RECEIVE_DESCRIPTORS,
                              FALSE,
                              Adapter->ReceiveBuffer,
                              Adapter->ReceiveBufferPa);
 
        Adapter->ReceiveBuffer = NULL;
        Adapter->ReceiveBufferEntrySize = 0;
    }
 
 
    if (Adapter->TransmitDescriptors != NULL)
    {
        /* Disassociate our shared buffer before freeing it to avoid NIC-induced memory corruption */
        if (Adapter->IoBase)
        {
            E1000WriteUlong(Adapter, E1000_REG_TDH, 0);
            E1000WriteUlong(Adapter, E1000_REG_TDT, 0);
        }
 
        NdisMFreeSharedMemory(Adapter->AdapterHandle,
                              sizeof(E1000_TRANSMIT_DESCRIPTOR) * NUM_TRANSMIT_DESCRIPTORS,
                              FALSE,
                              Adapter->TransmitDescriptors,
                              Adapter->TransmitDescriptorsPa);
 
        Adapter->TransmitDescriptors = NULL;
    }
 
 
 
    if (Adapter->IoPort)
    {
        NdisMDeregisterIoPortRange(Adapter->AdapterHandle,
                                   Adapter->IoPortAddress,
                                   Adapter->IoPortLength,
                                   Adapter->IoPort);
    }
 
    if (Adapter->IoBase)
    {
        NdisMUnmapIoSpace(Adapter->AdapterHandle, Adapter->IoBase, Adapter->IoLength);
    }
 
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportHalt().

NICSoftReset()

NDIS_STATUS NTAPI NICSoftReset

(

IN PE1000_ADAPTER

Adapter

)

Definition at line 531 of file hardware.c.

{
    ULONG Value, ResetAttempts;
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    NICDisableInterrupts(Adapter);
    E1000WriteUlong(Adapter, E1000_REG_RCTL, 0);
    E1000WriteUlong(Adapter, E1000_REG_TCTL, 0);
    E1000ReadUlong(Adapter, E1000_REG_CTRL, &Value);
    /* Write this using IO port, some devices cannot ack this otherwise */
    E1000WriteIoUlong(Adapter, E1000_REG_CTRL, Value | E1000_CTRL_RST);
 
 
    for (ResetAttempts = 0; ResetAttempts < MAX_RESET_ATTEMPTS; ResetAttempts++)
    {
        /* Wait 1us after reset (according to manual) */
        NdisStallExecution(1);
        E1000ReadUlong(Adapter, E1000_REG_CTRL, &Value);
 
        if (!(Value & E1000_CTRL_RST))
        {
            NDIS_DbgPrint(MAX_TRACE, ("Device is back (%u)\n", ResetAttempts));
 
            NICDisableInterrupts(Adapter);
            /* Clear out interrupts (the register is cleared upon read) */
            E1000ReadUlong(Adapter, E1000_REG_ICR, &Value);
 
            E1000ReadUlong(Adapter, E1000_REG_CTRL, &Value);
            Value &= ~(E1000_CTRL_LRST|E1000_CTRL_VME);
            Value |= (E1000_CTRL_ASDE|E1000_CTRL_SLU);
            E1000WriteUlong(Adapter, E1000_REG_CTRL, Value);
 
            return NDIS_STATUS_SUCCESS;
        }
    }
 
    NDIS_DbgPrint(MIN_TRACE, ("Device did not recover\n"));
    return NDIS_STATUS_FAILURE;
}

Referenced by MiniportInitialize(), and NICPowerOn().

NICUnregisterInterrupts()

NDIS_STATUS NTAPI NICUnregisterInterrupts

(

IN PE1000_ADAPTER

Adapter

)

Definition at line 417 of file hardware.c.

{
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    if (Adapter->InterruptRegistered)
    {
        NdisMDeregisterInterrupt(&Adapter->Interrupt);
        Adapter->InterruptRegistered = FALSE;
    }
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportHalt().

NICUpdateLinkStatus()

VOID NTAPI NICUpdateLinkStatus

(

IN PE1000_ADAPTER

Adapter

)

Definition at line 740 of file hardware.c.

{
    ULONG DeviceStatus;
    SIZE_T SpeedIndex;
    static ULONG SpeedValues[] = { 10, 100, 1000, 1000 };
 
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    E1000ReadUlong(Adapter, E1000_REG_STATUS, &DeviceStatus);
    Adapter->MediaState = (DeviceStatus & E1000_STATUS_LU) ? NdisMediaStateConnected : NdisMediaStateDisconnected;
    SpeedIndex = (DeviceStatus & E1000_STATUS_SPEEDMASK) >> E1000_STATUS_SPEEDSHIFT;
    Adapter->LinkSpeedMbps = SpeedValues[SpeedIndex];
}

Referenced by MiniportHandleInterrupt(), MiniportInitialize(), and MiniportISR().

NICUpdateMulticastList()

NDIS_STATUS NTAPI NICUpdateMulticastList

(

IN PE1000_ADAPTER

Adapter

)

Definition at line 693 of file hardware.c.

{
    UINT n;
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    // FIXME: Use 'Adapter->MulticastListSize'? Check the datasheet
    for (n = 0; n < MAXIMUM_MULTICAST_ADDRESSES; ++n)
    {
        ULONG Ral = *(ULONG *)Adapter->MulticastList[n].MacAddress;
        ULONG Rah = *(USHORT *)&Adapter->MulticastList[n].MacAddress[4];
 
        if (Rah || Ral)
        {
            Rah |= E1000_RAH_AV;
 
            E1000WriteUlong(Adapter, E1000_REG_RAL + (8*n), Ral);
            E1000WriteUlong(Adapter, E1000_REG_RAH + (8*n), Rah);
        }
        else
        {
            E1000WriteUlong(Adapter, E1000_REG_RAH + (8*n), 0);
            E1000WriteUlong(Adapter, E1000_REG_RAL + (8*n), 0);
        }
    }
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportInitialize(), and MiniportSetInformation().