dc21x4.h File Reference

#include <ndis.h>
#include <section_attribs.h>
#include "dc21x4hw.h"
#include "eeprom.h"
#include "media.h"
#include "util.h"
#include "sendrcv.h"

Include dependency graph for dc21x4.h:

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

Go to the source code of this file.

Classes
struct	_DC_TX_BUFFER_DATA
struct	_DC_STATISTICS
struct	_DC21X4_ADAPTER

Macros
#define	NO_KERNEL_LIST_ENTRY_CHECKS
#define	DC21X4_TAG   '4x12'
#define	DC_TRANSMIT_DESCRIPTORS   64
#define	DC_TRANSMIT_BLOCKS   48
#define	DC_TRANSMIT_BUFFERS   4
#define	DC_LOOPBACK_FRAMES   4
#define	DC_RECEIVE_BUFFERS_DEFAULT   64
#define	DC_RECEIVE_BUFFERS_MIN   8
#define	DC_RECEIVE_BUFFERS_EXTRA   16
#define	DC_RECEIVE_ARRAY_SIZE   16
#define	DC_MULTICAST_LIST_SIZE   36
#define	DC_MAXIMUM_FRAME_SIZE   1514
#define	DC_TRANSMIT_BLOCK_SIZE   1536
#define	DC_RECEIVE_BLOCK_SIZE   1536
#define	DC_ETHERNET_HEADER_SIZE   14
#define	DC_TX_UNDERRUN_LIMIT   5
#define	DC_INTERRUPT_PROCESSING_LIMIT   8
#define	DC_FRAGMENTATION_THRESHOLD   32
#define	DC_PACKET_FILTERS
#define	DC_LOOPBACK_FRAME_SIZE   64
#define	DC_TBD_RESERVE   (2 + DC_LOOPBACK_FRAMES) /* (+2 for setup frame) */
#define	DC_TCB_RESERVE   (1 + DC_LOOPBACK_FRAMES) /* (+1 for setup frame) */
#define	DC_EVENT_SETUP_FRAME_COMPLETED   0x00000001
#define	DC_NEED_RX_OVERFLOW_WORKAROUND   0x80000000
#define	DC_SIA_GPIO   0x00000001
#define	DC_SIA_ANALOG_CONTROL   0x00000002
#define	DC_HAS_POWER_MANAGEMENT   0x00000004
#define	DC_HAS_POWER_SAVING   0x00000008
#define	DC_HAS_MII   0x00000010
#define	DC_PERFECT_FILTERING_ONLY   0x00000020
#define	DC_ENABLE_PCI_COMMANDS   0x00000040
#define	DC_MII_AUTOSENSE   0x00000080
#define	DC_HAS_TIMER   0x00000100
#define	DC_ACTIVE   0x80000000
#define	DC_IO_MAPPED   0x00000001
#define	DC_IRQ_SHARED   0x00000002
#define	DC_FIRST_SETUP   0x00000004
#define	DC_AUTOSENSE   0x00000008
#define	DC_MODE_AUTONEG_MASK   0x0000000F
#define	DC_MODE_PORT_AUTOSENSE   0x00000010
#define	DC_MODE_TEST_PACKET   0x00000020
#define	DC_MODE_AUI_FAILED   0x00000040
#define	DC_MODE_BNC_FAILED   0x00000080
#define	DC_MODE_AUTONEG_NONE   0x00000000
#define	DC_MODE_AUTONEG_WAIT_INTERRUPT   0x00000001
#define	DC_MODE_AUTONEG_LINK_STATUS_CHECK   0x00000002
#define	DC_WRITE(Adapter, Register, Value)    NdisRawWritePortUlong((PULONG)((Adapter)->IoBase + (Register)), (Value));

Typedefs
typedef struct _DC21X4_ADAPTER	DC21X4_ADAPTER
typedef struct _DC21X4_ADAPTER *	PDC21X4_ADAPTER
typedef struct _DC_TCB	DC_TCB
typedef struct _DC_TCB *	PDC_TCB
typedef struct _DC_RCB	DC_RCB
typedef struct _DC_RCB *	PDC_RCB
typedef struct _DC_COALESCE_BUFFER	DC_COALESCE_BUFFER
typedef struct _DC_COALESCE_BUFFER *	PDC_COALESCE_BUFFER
typedef VOID()	MEDIA_HANDLE_LINK_STATE_CHANGE(_In_ PDC21X4_ADAPTER Adapter, _In_ ULONG InterruptStatus)
typedef MEDIA_HANDLE_LINK_STATE_CHANGE *	PMEDIA_HANDLE_LINK_STATE_CHANGE
typedef struct _DC_TX_BUFFER_DATA	DC_TX_BUFFER_DATA
typedef struct _DC_TX_BUFFER_DATA *	PDC_TX_BUFFER_DATA
typedef struct _DC_STATISTICS	DC_STATISTICS
typedef struct _DC_STATISTICS *	PDC_STATISTICS

Functions
FORCEINLINE ULONG	DC_READ (_In_ PDC21X4_ADAPTER Adapter, _In_ DC_CSR Register)
NDIS_STATUS NTAPI	DcInitialize (_Out_ PNDIS_STATUS OpenErrorStatus, _Out_ PUINT SelectedMediumIndex, _In_ PNDIS_MEDIUM MediumArray, _In_ UINT MediumArraySize, _In_ NDIS_HANDLE MiniportAdapterHandle, _In_ NDIS_HANDLE WrapperConfigurationContext)
VOID NTAPI	DcSendPackets (_In_ NDIS_HANDLE MiniportAdapterContext, _In_ PPNDIS_PACKET PacketArray, _In_ UINT NumberOfPackets)
VOID NTAPI	DcCancelSendPackets (_In_ NDIS_HANDLE MiniportAdapterContext, _In_ PVOID CancelId)
VOID	DcProcessPendingPackets (_In_ PDC21X4_ADAPTER Adapter)
VOID NTAPI	DcReturnPacket (_In_ NDIS_HANDLE MiniportAdapterContext, _In_ PNDIS_PACKET Packet)
NDIS_STATUS NTAPI	DcQueryInformation (_In_ NDIS_HANDLE MiniportAdapterContext, _In_ NDIS_OID Oid, _In_ PVOID InformationBuffer, _In_ ULONG InformationBufferLength, _Out_ PULONG BytesWritten, _Out_ PULONG BytesNeeded)
NDIS_STATUS NTAPI	DcSetInformation (_In_ NDIS_HANDLE MiniportAdapterContext, _In_ NDIS_OID Oid, _In_ PVOID InformationBuffer, _In_ ULONG InformationBufferLength, _Out_ PULONG BytesRead, _Out_ PULONG BytesNeeded)
VOID NTAPI	DcIsr (_Out_ PBOOLEAN InterruptRecognized, _Out_ PBOOLEAN QueueMiniportHandleInterrupt, _In_ NDIS_HANDLE MiniportAdapterContext)
VOID NTAPI	DcHandleInterrupt (_In_ NDIS_HANDLE MiniportAdapterContext)
VOID NTAPI	DcPowerWorker (_In_ PNDIS_WORK_ITEM WorkItem, _In_opt_ PVOID Context)
NDIS_STATUS	DcSetPower (_In_ PDC21X4_ADAPTER Adapter, _In_ NDIS_DEVICE_POWER_STATE PowerState)
NDIS_STATUS	DcAddWakeUpPattern (_In_ PDC21X4_ADAPTER Adapter, _In_ PNDIS_PM_PACKET_PATTERN PmPattern)
NDIS_STATUS	DcRemoveWakeUpPattern (_In_ PDC21X4_ADAPTER Adapter, _In_ PNDIS_PM_PACKET_PATTERN PmPattern)
VOID	DcFreeAdapter (_In_ __drv_freesMem(Mem) PDC21X4_ADAPTER Adapter)
VOID NTAPI	DcResetWorker (_In_ PNDIS_WORK_ITEM WorkItem, _In_opt_ PVOID Context)
DECLSPEC_NOINLINE VOID	DcStopAdapter (_In_ PDC21X4_ADAPTER Adapter, _In_ BOOLEAN WaitForPackets)
VOID	DcStartAdapter (_In_ PDC21X4_ADAPTER Adapter)
NDIS_STATUS	DcSetupAdapter (_In_ PDC21X4_ADAPTER Adapter)
NDIS_STATUS	DcReadEeprom (_In_ PDC21X4_ADAPTER Adapter)
VOID	DcFreeEeprom (_In_ PDC21X4_ADAPTER Adapter)
VOID	DcInitTxRing (_In_ PDC21X4_ADAPTER Adapter)
VOID	DcInitRxRing (_In_ PDC21X4_ADAPTER Adapter)
ULONG	DcEthernetCrc (_In_reads_bytes_(Size) const VOID *Buffer, _In_ ULONG Size)
VOID	DcDisableHw (_In_ PDC21X4_ADAPTER Adapter)
VOID	DcStopTxRxProcess (_In_ PDC21X4_ADAPTER Adapter)
VOID	DcWriteGpio (_In_ PDC21X4_ADAPTER Adapter, _In_ ULONG Value)
VOID	DcWriteSia (_In_ PDC21X4_ADAPTER Adapter, _In_ ULONG Csr13, _In_ ULONG Csr14, _In_ ULONG Csr15)
VOID	DcTestPacket (_In_ PDC21X4_ADAPTER Adapter)
VOID	DcSetupFrameInitialize (_In_ PDC21X4_ADAPTER Adapter)
BOOLEAN	DcSetupFrameDownload (_In_ PDC21X4_ADAPTER Adapter, _In_ BOOLEAN WaitForCompletion)
NDIS_STATUS	DcApplyPacketFilter (_In_ PDC21X4_ADAPTER Adapter, _In_ ULONG PacketFilter)
NDIS_STATUS	DcUpdateMulticastList (_In_ PDC21X4_ADAPTER Adapter)
VOID	DcPowerSave (_In_ PDC21X4_ADAPTER Adapter, _In_ BOOLEAN Enable)
BOOLEAN	DcFindMiiPhy (_In_ PDC21X4_ADAPTER Adapter)
BOOLEAN	MiiWrite (_In_ PDC21X4_ADAPTER Adapter, _In_ ULONG PhyAddress, _In_ ULONG RegAddress, _In_ ULONG Data)
BOOLEAN	MiiRead (_In_ PDC21X4_ADAPTER Adapter, _In_ ULONG PhyAddress, _In_ ULONG RegAddress, _Out_ PULONG Data)
VOID	HpnaPhyInit (_In_ PDC21X4_ADAPTER Adapter)
VOID NTAPI	DcTransmitTimeoutRecoveryWorker (_In_ PNDIS_WORK_ITEM WorkItem, _In_opt_ PVOID Context)
VOID	MediaInitMediaList (_In_ PDC21X4_ADAPTER Adapter)
VOID	MediaInitDefaultMedia (_In_ PDC21X4_ADAPTER Adapter, _In_ ULONG MediaNumber)
VOID	MediaIndicateConnect (_In_ PDC21X4_ADAPTER Adapter, _In_ BOOLEAN LinkUp)
VOID	MediaSelectMiiPort (_In_ PDC21X4_ADAPTER Adapter, _In_ BOOLEAN ResetPhy)
VOID	MediaMiiSelect (_In_ PDC21X4_ADAPTER Adapter)
BOOLEAN	MediaMiiCheckLink (_In_ PDC21X4_ADAPTER Adapter)
VOID	MediaSiaSelect (_In_ PDC21X4_ADAPTER Adapter)
VOID	MediaGprSelect (_In_ PDC21X4_ADAPTER Adapter)

Variables
LIST_ENTRY	SRompAdapterList
DRIVER_INITIALIZE	DriverEntry
NDIS_TIMER_FUNCTION	MediaMonitor21040Dpc
NDIS_TIMER_FUNCTION	MediaMonitor21041Dpc
NDIS_TIMER_FUNCTION	MediaMonitor21140Dpc
NDIS_TIMER_FUNCTION	MediaMonitor21143Dpc
MEDIA_HANDLE_LINK_STATE_CHANGE	MediaLinkStateChange21040
MEDIA_HANDLE_LINK_STATE_CHANGE	MediaLinkStateChange21041
MEDIA_HANDLE_LINK_STATE_CHANGE	MediaLinkStateChange21143

Macro Definition Documentation

DC21X4_TAG

#define DC21X4_TAG   '4x12'

Definition at line 21 of file dc21x4.h.

DC_ACTIVE

#define DC_ACTIVE   0x80000000

Definition at line 120 of file dc21x4.h.

DC_AUTOSENSE

#define DC_AUTOSENSE   0x00000008

Definition at line 124 of file dc21x4.h.

DC_ENABLE_PCI_COMMANDS

#define DC_ENABLE_PCI_COMMANDS   0x00000040

Definition at line 115 of file dc21x4.h.

DC_ETHERNET_HEADER_SIZE

#define DC_ETHERNET_HEADER_SIZE   14

Definition at line 39 of file dc21x4.h.

DC_EVENT_SETUP_FRAME_COMPLETED

#define DC_EVENT_SETUP_FRAME_COMPLETED   0x00000001

Definition at line 59 of file dc21x4.h.

DC_FIRST_SETUP

#define DC_FIRST_SETUP   0x00000004

Definition at line 123 of file dc21x4.h.

DC_FRAGMENTATION_THRESHOLD

#define DC_FRAGMENTATION_THRESHOLD   32

Definition at line 44 of file dc21x4.h.

DC_HAS_MII

#define DC_HAS_MII   0x00000010

Definition at line 113 of file dc21x4.h.

DC_HAS_POWER_MANAGEMENT

#define DC_HAS_POWER_MANAGEMENT   0x00000004

Definition at line 111 of file dc21x4.h.

DC_HAS_POWER_SAVING

#define DC_HAS_POWER_SAVING   0x00000008

Definition at line 112 of file dc21x4.h.

DC_HAS_TIMER

#define DC_HAS_TIMER   0x00000100

Definition at line 117 of file dc21x4.h.

DC_INTERRUPT_PROCESSING_LIMIT

#define DC_INTERRUPT_PROCESSING_LIMIT   8

Definition at line 42 of file dc21x4.h.

DC_IO_MAPPED

#define DC_IO_MAPPED   0x00000001

Definition at line 121 of file dc21x4.h.

DC_IRQ_SHARED

#define DC_IRQ_SHARED   0x00000002

Definition at line 122 of file dc21x4.h.

DC_LOOPBACK_FRAME_SIZE

#define DC_LOOPBACK_FRAME_SIZE   64

Definition at line 53 of file dc21x4.h.

DC_LOOPBACK_FRAMES

#define DC_LOOPBACK_FRAMES   4

Definition at line 26 of file dc21x4.h.

DC_MAXIMUM_FRAME_SIZE

#define DC_MAXIMUM_FRAME_SIZE   1514

Definition at line 36 of file dc21x4.h.

DC_MII_AUTOSENSE

#define DC_MII_AUTOSENSE   0x00000080

Definition at line 116 of file dc21x4.h.

DC_MODE_AUI_FAILED

#define DC_MODE_AUI_FAILED   0x00000040

Definition at line 166 of file dc21x4.h.

DC_MODE_AUTONEG_LINK_STATUS_CHECK

#define DC_MODE_AUTONEG_LINK_STATUS_CHECK   0x00000002

Definition at line 171 of file dc21x4.h.

DC_MODE_AUTONEG_MASK

#define DC_MODE_AUTONEG_MASK   0x0000000F

Definition at line 163 of file dc21x4.h.

DC_MODE_AUTONEG_NONE

#define DC_MODE_AUTONEG_NONE   0x00000000

Definition at line 169 of file dc21x4.h.

DC_MODE_AUTONEG_WAIT_INTERRUPT

#define DC_MODE_AUTONEG_WAIT_INTERRUPT   0x00000001

Definition at line 170 of file dc21x4.h.

DC_MODE_BNC_FAILED

#define DC_MODE_BNC_FAILED   0x00000080

Definition at line 167 of file dc21x4.h.

DC_MODE_PORT_AUTOSENSE

#define DC_MODE_PORT_AUTOSENSE   0x00000010

Definition at line 164 of file dc21x4.h.

DC_MODE_TEST_PACKET

#define DC_MODE_TEST_PACKET   0x00000020

Definition at line 165 of file dc21x4.h.

DC_MULTICAST_LIST_SIZE

#define DC_MULTICAST_LIST_SIZE   36

Definition at line 34 of file dc21x4.h.

DC_NEED_RX_OVERFLOW_WORKAROUND

#define DC_NEED_RX_OVERFLOW_WORKAROUND   0x80000000

Definition at line 108 of file dc21x4.h.

DC_PACKET_FILTERS

#define DC_PACKET_FILTERS

Value:

    ( \
    NDIS_PACKET_TYPE_DIRECTED | \
    NDIS_PACKET_TYPE_MULTICAST | \
    NDIS_PACKET_TYPE_BROADCAST | \
    NDIS_PACKET_TYPE_PROMISCUOUS | \
    NDIS_PACKET_TYPE_ALL_MULTICAST)

Definition at line 46 of file dc21x4.h.

DC_PERFECT_FILTERING_ONLY

#define DC_PERFECT_FILTERING_ONLY   0x00000020

Definition at line 114 of file dc21x4.h.

DC_RECEIVE_ARRAY_SIZE

#define DC_RECEIVE_ARRAY_SIZE   16

Definition at line 32 of file dc21x4.h.

DC_RECEIVE_BLOCK_SIZE

#define DC_RECEIVE_BLOCK_SIZE   1536

Definition at line 38 of file dc21x4.h.

DC_RECEIVE_BUFFERS_DEFAULT

#define DC_RECEIVE_BUFFERS_DEFAULT   64

Definition at line 28 of file dc21x4.h.

DC_RECEIVE_BUFFERS_EXTRA

#define DC_RECEIVE_BUFFERS_EXTRA   16

Definition at line 30 of file dc21x4.h.

DC_RECEIVE_BUFFERS_MIN

#define DC_RECEIVE_BUFFERS_MIN   8

Definition at line 29 of file dc21x4.h.

DC_SIA_ANALOG_CONTROL

#define DC_SIA_ANALOG_CONTROL   0x00000002

Definition at line 110 of file dc21x4.h.

DC_SIA_GPIO

#define DC_SIA_GPIO   0x00000001

Definition at line 109 of file dc21x4.h.

DC_TBD_RESERVE

#define DC_TBD_RESERVE   (2 + DC_LOOPBACK_FRAMES) /* (+2 for setup frame) */

Definition at line 56 of file dc21x4.h.

DC_TCB_RESERVE

#define DC_TCB_RESERVE   (1 + DC_LOOPBACK_FRAMES) /* (+1 for setup frame) */

Definition at line 57 of file dc21x4.h.

DC_TRANSMIT_BLOCK_SIZE

#define DC_TRANSMIT_BLOCK_SIZE   1536

Definition at line 37 of file dc21x4.h.

DC_TRANSMIT_BLOCKS

#define DC_TRANSMIT_BLOCKS   48

Definition at line 24 of file dc21x4.h.

DC_TRANSMIT_BUFFERS

#define DC_TRANSMIT_BUFFERS   4

Definition at line 25 of file dc21x4.h.

DC_TRANSMIT_DESCRIPTORS

#define DC_TRANSMIT_DESCRIPTORS   64

Definition at line 23 of file dc21x4.h.

DC_TX_UNDERRUN_LIMIT

#define DC_TX_UNDERRUN_LIMIT   5

Definition at line 41 of file dc21x4.h.

DC_WRITE

#define DC_WRITE	(		Adapter,
			Register,
			Value
	)		NdisRawWritePortUlong((PULONG)((Adapter)->IoBase + (Register)), (Value));

Definition at line 272 of file dc21x4.h.

NO_KERNEL_LIST_ENTRY_CHECKS

#define NO_KERNEL_LIST_ENTRY_CHECKS

Definition at line 11 of file dc21x4.h.

Typedef Documentation

DC21X4_ADAPTER

typedef struct _DC21X4_ADAPTER DC21X4_ADAPTER

Definition at line 61 of file dc21x4.h.

DC_COALESCE_BUFFER

typedef struct _DC_COALESCE_BUFFER DC_COALESCE_BUFFER

Definition at line 64 of file dc21x4.h.

DC_RCB

typedef struct _DC_RCB DC_RCB

Definition at line 63 of file dc21x4.h.

DC_STATISTICS

typedef struct _DC_STATISTICS DC_STATISTICS

DC_TCB

typedef struct _DC_TCB DC_TCB

Definition at line 62 of file dc21x4.h.

DC_TX_BUFFER_DATA

typedef struct _DC_TX_BUFFER_DATA DC_TX_BUFFER_DATA

MEDIA_HANDLE_LINK_STATE_CHANGE

typedef VOID() MEDIA_HANDLE_LINK_STATE_CHANGE(_In_ PDC21X4_ADAPTER Adapter, _In_ ULONG InterruptStatus)

Definition at line 66 of file dc21x4.h.

PDC21X4_ADAPTER

typedef struct _DC21X4_ADAPTER * PDC21X4_ADAPTER

Definition at line 61 of file dc21x4.h.

PDC_COALESCE_BUFFER

typedef struct _DC_COALESCE_BUFFER * PDC_COALESCE_BUFFER

Definition at line 64 of file dc21x4.h.

PDC_RCB

typedef struct _DC_RCB * PDC_RCB

Definition at line 63 of file dc21x4.h.

PDC_STATISTICS

typedef struct _DC_STATISTICS * PDC_STATISTICS

PDC_TCB

typedef struct _DC_TCB * PDC_TCB

Definition at line 62 of file dc21x4.h.

PDC_TX_BUFFER_DATA

typedef struct _DC_TX_BUFFER_DATA * PDC_TX_BUFFER_DATA

PMEDIA_HANDLE_LINK_STATE_CHANGE

typedef MEDIA_HANDLE_LINK_STATE_CHANGE* PMEDIA_HANDLE_LINK_STATE_CHANGE

Definition at line 70 of file dc21x4.h.

Function Documentation

DC_READ()

FORCEINLINE ULONG DC_READ	(	_In_ PDC21X4_ADAPTER	Adapter,
		_In_ DC_CSR	Register
	)

Definition at line 262 of file dc21x4.h.

{
    ULONG Value;
 
    NdisRawReadPortUlong((PULONG)(Adapter->IoBase + Register), &Value);
    return Value;
}

Referenced by AddressRomReadData(), DcCheckForHang(), DcHandleInterrupt(), DcHandleRxReceivedFrames(), DcInitialize(), DcIsr(), DcPowerDown(), DcQueryInformation(), DcQueryStatisticCounter(), DcResetWorker(), DcStopRxProcess(), DcStopTxRxProcess(), DcTestPacket(), HpnaPhyInit(), MediaGprCheckLink(), MediaLinkStateChange21040(), MediaLinkStateChange21041(), MediaLinkStateChange21143(), MediaMonitor143(), MediaMonitor21040Dpc(), MediaMonitor21041Dpc(), MediaMonitor21143Dpc(), MiiRead(), and SRomDetectAddressBusWidth().

DcAddWakeUpPattern()

NDIS_STATUS DcAddWakeUpPattern	(	_In_ PDC21X4_ADAPTER	Adapter,
		_In_ PNDIS_PM_PACKET_PATTERN	PmPattern
	)

Definition at line 215 of file power.c.

{
    // TODO: Not implemented
    ERR("FIXME: Not implemented\n");
    return NDIS_STATUS_NOT_SUPPORTED;
}

Referenced by DcSetInformation().

DcApplyPacketFilter()

NDIS_STATUS DcApplyPacketFilter	(	_In_ PDC21X4_ADAPTER	Adapter,
		_In_ ULONG	PacketFilter
	)

Definition at line 401 of file hardware.c.

{
    ULONG OpMode, OldPacketFilter;
 
    INFO("Packet filter value 0x%lx\n", PacketFilter);
 
    NdisAcquireSpinLock(&Adapter->ModeLock);
 
    /* Update the filtering mode */
    OpMode = Adapter->OpMode;
    OpMode &= ~(DC_OPMODE_RX_PROMISCUOUS | DC_OPMODE_RX_ALL_MULTICAST);
    if (PacketFilter & NDIS_PACKET_TYPE_PROMISCUOUS)
    {
        OpMode |= DC_OPMODE_RX_PROMISCUOUS;
    }
    else if (PacketFilter & NDIS_PACKET_TYPE_ALL_MULTICAST)
    {
        OpMode |= DC_OPMODE_RX_ALL_MULTICAST;
    }
    Adapter->OpMode = OpMode;
    DC_WRITE(Adapter, DcCsr6_OpMode, OpMode);
 
    NdisReleaseSpinLock(&Adapter->ModeLock);
 
    OldPacketFilter = Adapter->PacketFilter;
    Adapter->PacketFilter = PacketFilter;
 
    /* Program the NIC to receive or reject broadcast frames */
    if ((OldPacketFilter ^ PacketFilter) & NDIS_PACKET_TYPE_BROADCAST)
    {
        return DcUpdateMulticastList(Adapter);
    }
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by DcSetInformation().

DcCancelSendPackets()

VOID NTAPI DcCancelSendPackets	(	_In_ NDIS_HANDLE	MiniportAdapterContext,
		_In_ PVOID	CancelId
	)

Definition at line 271 of file send.c.

{
    PDC21X4_ADAPTER Adapter = (PDC21X4_ADAPTER)MiniportAdapterContext;
    LIST_ENTRY DoneList;
    PLIST_ENTRY Entry, NextEntry;
 
    TRACE("Called\n");
 
    InitializeListHead(&DoneList);
 
    NdisAcquireSpinLock(&Adapter->SendLock);
 
    NextEntry = Adapter->SendQueueList.Flink;
    while (NextEntry != &Adapter->SendQueueList)
    {
        PNDIS_PACKET Packet;
 
        Entry = NextEntry;
        NextEntry = NextEntry->Flink;
 
        Packet = DC_PACKET_FROM_LIST_ENTRY(Entry);
 
        if (NDIS_GET_PACKET_CANCEL_ID(Packet) == CancelId)
        {
            RemoveEntryList(DC_LIST_ENTRY_FROM_PACKET(Packet));
 
            InsertTailList(&DoneList, DC_LIST_ENTRY_FROM_PACKET(Packet));
        }
    }
 
    NdisReleaseSpinLock(&Adapter->SendLock);
 
    while (!IsListEmpty(&DoneList))
    {
        Entry = RemoveHeadList(&DoneList);
 
        NdisMSendComplete(Adapter->AdapterHandle,
                          DC_PACKET_FROM_LIST_ENTRY(Entry),
                          NDIS_STATUS_REQUEST_ABORTED);
    }
}

Referenced by DriverEntry().

DcDisableHw()

VOID DcDisableHw

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 17 of file hardware.c.

{
    ULONG OpMode;
 
    /* Disable interrupts */
    DC_WRITE(Adapter, DcCsr7_IrqMask, 0);
 
    /* Stop DMA */
    OpMode = Adapter->OpMode;
    OpMode &= ~(DC_OPMODE_RX_ENABLE | DC_OPMODE_TX_ENABLE);
    DC_WRITE(Adapter, DcCsr6_OpMode, OpMode);
 
    /* Put the adapter to snooze mode */
    DcPowerSave(Adapter, TRUE);
 
    /* Perform a software reset */
    DC_WRITE(Adapter, DcCsr0_BusMode, DC_BUS_MODE_SOFT_RESET);
}

Referenced by DcHalt(), DcInitialize(), and DcShutdown().

DcEthernetCrc()

ULONG DcEthernetCrc	(	_In_reads_bytes_(Size) const VOID *	Buffer,
		_In_ ULONG	Size
	)

Definition at line 17 of file dc21x4.c.

{
    ULONG i, j, Crc;
    const UCHAR* Data = Buffer;
 
    Crc = 0xFFFFFFFF;
    for (i = 0; i < Size; ++i)
    {
        Crc ^= Data[i];
        for (j = 8; j > 0; j--)
        {
            /* CRC-32 polynomial little-endian */
            Crc = (Crc >> 1) ^ (-(LONG)(Crc & 1) & 0xEDB88320);
        }
    }
 
    return Crc;
}

Referenced by DcSetupFrameImperfectFiltering().

DcFindMiiPhy()

BOOLEAN DcFindMiiPhy

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 217 of file phy.c.

{
    ULONG Phy;
 
    PAGED_CODE();
 
    /* Look for the first connected PHY */
    for (Phy = 1; Phy <= MII_MAX_PHY_ADDRESSES; ++Phy)
    {
        ULONG PhyAddress = Phy % MII_MAX_PHY_ADDRESSES; /* Check the PHY 0 last */
        ULONG MiiStatus;
#if DBG
        ULONG PhyIdLow, PhyIdHigh, MiiControl, MiiAdvertise;
#endif
 
        /*
         * Read the status register. Some PHYs, such as the ML6692,
         * don't implement the IEEE ID registers.
         */
        if (!MiiRead(Adapter, PhyAddress, MII_STATUS, &MiiStatus))
            continue;
        if (MiiStatus == 0xFFFF || MiiStatus == 0)
            continue;
 
#if DBG
        MiiRead(Adapter, PhyAddress, MII_PHY_ID1, &PhyIdLow);
        MiiRead(Adapter, PhyAddress, MII_PHY_ID2, &PhyIdHigh);
        MiiRead(Adapter, PhyAddress, MII_CONTROL, &MiiControl);
        MiiRead(Adapter, PhyAddress, MII_AUTONEG_ADVERTISE, &MiiAdvertise);
 
        INFO_VERB("Found PHY at address %u: ID %04lx:%04lx, Ctrl %04lx, Status %04lx, Adv %04lx\n",
                  PhyAddress,
                  PhyIdLow,
                  PhyIdHigh,
                  MiiControl,
                  MiiStatus,
                  MiiAdvertise);
#endif
 
        Adapter->PhyAddress = PhyAddress;
 
        return TRUE;
    }
 
    return FALSE;
}

Referenced by DcInitialize().

DcFreeAdapter()

VOID DcFreeAdapter

(

_In_ __drv_freesMem(Mem) PDC21X4_ADAPTER

Adapter

)

Definition at line 1022 of file init.c.

{
    ULONG i;
 
    PAGED_CODE();
 
    DcFreeEeprom(Adapter);
 
    if (Adapter->Interrupt.InterruptObject)
    {
        NdisMDeregisterInterrupt(&Adapter->Interrupt);
    }
 
    if (Adapter->IoBase)
    {
        if (Adapter->Flags & DC_IO_MAPPED)
        {
            NdisMUnmapIoSpace(Adapter->AdapterHandle,
                              Adapter->IoBase,
                              DC_IO_LENGTH);
        }
        else
        {
            NdisMDeregisterIoPortRange(Adapter->AdapterHandle,
                                       Adapter->IoBaseAddress.LowPart,
                                       DC_IO_LENGTH,
                                       Adapter->IoBase);
        }
    }
 
    if (Adapter->HeadTcb)
    {
        NdisFreeMemory(Adapter->HeadTcb, sizeof(DC_TCB) * DC_TRANSMIT_BLOCKS, 0);
    }
    if (Adapter->RcbArray)
    {
        NdisFreeMemory(Adapter->RcbArray, sizeof(PVOID) * Adapter->RcbCount, 0);
    }
    if (Adapter->SetupFrameSaved)
    {
        NdisFreeMemory(Adapter->SetupFrameSaved, DC_SETUP_FRAME_SIZE, 0);
    }
 
    while (Adapter->AllocRcbList.Next)
    {
        PSINGLE_LIST_ENTRY Entry = PopEntryList(&Adapter->AllocRcbList);
        PDC_RCB Rcb = CONTAINING_RECORD(Entry, DC_RCB, AllocListEntry);
 
        DcFreeRcb(Adapter, Rcb);
    }
 
    if (Adapter->RbdOriginal)
    {
        NdisMFreeSharedMemory(Adapter->AdapterHandle,
                              DC_MEM_BLOCK_SIZE_RBD,
                              FALSE, /* Non-cached */
                              Adapter->RbdOriginal,
                              Adapter->RbdPhysOriginal);
    }
    if (Adapter->TbdOriginal)
    {
        NdisMFreeSharedMemory(Adapter->AdapterHandle,
                              DC_MEM_BLOCK_SIZE_TBD_AUX,
                              FALSE, /* Non-cached */
                              Adapter->TbdOriginal,
                              Adapter->TbdPhysOriginal);
    }
    if (Adapter->CoalesceBuffer)
    {
        for (i = 0; i < DC_TRANSMIT_BUFFERS; ++i)
        {
            PDC_TX_BUFFER_DATA SendBufferData = &Adapter->SendBufferData[i];
 
            if (!SendBufferData->VirtualAddress)
                continue;
 
            NdisMFreeSharedMemory(Adapter->AdapterHandle,
                                  DC_MEM_BLOCK_SIZE_TX_BUFFER,
                                  FALSE, /* Non-cached */
                                  SendBufferData->VirtualAddress,
                                  SendBufferData->PhysicalAddress);
        }
    }
 
    if (Adapter->PacketPool)
        NdisFreePacketPool(Adapter->PacketPool);
    if (Adapter->BufferPool)
        NdisFreeBufferPool(Adapter->BufferPool);
 
    if (Adapter->SendLock.SpinLock)
        NdisFreeSpinLock(&Adapter->SendLock);
    if (Adapter->ReceiveLock.SpinLock)
        NdisFreeSpinLock(&Adapter->ReceiveLock);
    if (Adapter->ModeLock.SpinLock)
        NdisFreeSpinLock(&Adapter->ModeLock);
 
    NdisFreeMemory(Adapter->AdapterOriginal, sizeof(*Adapter), 0);
}

Referenced by DcHalt(), and DcInitialize().

DcFreeEeprom()

VOID DcFreeEeprom

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 1444 of file eeprom.c.

{
    PDC_SROM_ENTRY SRomEntry;
 
    PAGED_CODE();
 
    SRomEntry = Adapter->SRomEntry;
    if (!SRomEntry)
        return;
 
    SRomAcquireListMutex();
 
    /* Unregister the port */
    SRomEntry->DeviceBitmap &= ~(1 << Adapter->DeviceNumber);
 
    /*
     * Free the SROM as soon as the last registered port has removed.
     * We can't free it in an unload handler
     * as the bus numbers can be changed by a resource rebalance.
     */
    if (SRomEntry->DeviceBitmap == 0)
    {
        INFO("Freeing SROM %p at %u:%u\n",
             SRomEntry,
             SRomEntry->BusNumber,
             SRomEntry->DeviceNumber);
 
        RemoveEntryList(&SRomEntry->ListEntry);
 
        NdisFreeMemory(SRomEntry, 0, 0);
    }
 
    SRomReleaseListMutex();
}

Referenced by DcFreeAdapter().

DcHandleInterrupt()

VOID NTAPI DcHandleInterrupt

(

_In_ NDIS_HANDLE

MiniportAdapterContext

)

Definition at line 514 of file interrupt.c.

{
    ULONG InterruptStatus, IoLimit;
    PDC21X4_ADAPTER Adapter = (PDC21X4_ADAPTER)MiniportAdapterContext;
 
    TRACE("Events %08lx\n", Adapter->InterruptStatus);
 
    if (!(Adapter->Flags & DC_ACTIVE))
        return;
 
    IoLimit = DC_INTERRUPT_PROCESSING_LIMIT;
    InterruptStatus = Adapter->InterruptStatus;
 
    /* Loop until the condition to stop is encountered */
    while (TRUE)
    {
        /* Uncommon interrupts */
        if (InterruptStatus & DC_IRQ_ABNORMAL_SUMMARY)
        {
            /* PCI bus error detected */
            if (InterruptStatus & DC_IRQ_SYSTEM_ERROR)
            {
                DcHandleSystemError(Adapter, InterruptStatus);
                return;
            }
 
            /* Transmit jabber timeout */
            if (InterruptStatus & DC_IRQ_TX_JABBER_TIMEOUT)
            {
                DcHandleTxJabberTimeout(Adapter);
            }
 
            /* Link state changed */
            if (InterruptStatus & Adapter->LinkStateChangeMask)
            {
                Adapter->HandleLinkStateChange(Adapter, InterruptStatus);
            }
        }
 
        /* Handling receive interrupts */
        if (InterruptStatus & (DC_IRQ_RX_OK | DC_IRQ_RX_STOPPED))
        {
            DcHandleRx(Adapter);
        }
 
        /* Handling transmit interrupts */
        if (InterruptStatus & (DC_IRQ_TX_OK | DC_IRQ_TX_STOPPED))
        {
            DcHandleTx(Adapter);
        }
 
        /* Transmit underflow error detected */
        if (InterruptStatus & DC_IRQ_TX_UNDERFLOW)
        {
            DcAdjustTxFifoThreshold(Adapter);
        }
 
        /* Limit in order to avoid doing too much work at DPC level */
        if (!--IoLimit)
            break;
 
        /* Check if new events have occurred */
        InterruptStatus = DC_READ(Adapter, DcCsr5_Status);
        if (InterruptStatus == 0xFFFFFFFF || !(InterruptStatus & Adapter->InterruptMask))
            break;
 
        /* Acknowledge the events */
        DC_WRITE(Adapter, DcCsr5_Status, InterruptStatus);
    }
 
    /* TODO: Add interrupt mitigation (CSR11) */
 
    /* Reenable interrupts */
    _InterlockedExchange((PLONG)&Adapter->CurrentInterruptMask, Adapter->InterruptMask);
    DC_WRITE(Adapter, DcCsr7_IrqMask, Adapter->InterruptMask);
}

Referenced by DriverEntry().

DcInitialize()

NDIS_STATUS NTAPI DcInitialize	(	_Out_ PNDIS_STATUS	OpenErrorStatus,
		_Out_ PUINT	SelectedMediumIndex,
		_In_ PNDIS_MEDIUM	MediumArray,
		_In_ UINT	MediumArraySize,
		_In_ NDIS_HANDLE	MiniportAdapterHandle,
		_In_ NDIS_HANDLE	WrapperConfigurationContext
	)

Definition at line 1125 of file init.c.

{
    PDC21X4_ADAPTER Adapter;
    PVOID UnalignedAdapter;
    NDIS_STATUS Status;
    ULONG Alignment, AdapterSize, OpMode;
    BOOLEAN Success;
    UINT i;
 
    INFO("Called\n");
 
    PAGED_CODE();
 
    for (i = 0; i < MediumArraySize; ++i)
    {
        if (MediumArray[i] == NdisMedium802_3)
        {
            *SelectedMediumIndex = i;
            break;
        }
    }
    if (i == MediumArraySize)
    {
        ERR("No supported media\n");
        return NDIS_STATUS_UNSUPPORTED_MEDIA;
    }
 
    Alignment = NdisGetSharedDataAlignment();
    AdapterSize = sizeof(*Adapter) + Alignment;
 
    Status = NdisAllocateMemoryWithTag((PVOID*)&UnalignedAdapter, AdapterSize, DC21X4_TAG);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        ERR("Failed to allocate adapter context\n");
        return NDIS_STATUS_RESOURCES;
    }
    NdisZeroMemory(UnalignedAdapter, AdapterSize);
 
    Adapter = ALIGN_UP_POINTER_BY(UnalignedAdapter, Alignment);
    Adapter->AdapterOriginal = UnalignedAdapter;
    Adapter->AdapterSize = AdapterSize;
    Adapter->AdapterHandle = MiniportAdapterHandle;
    Adapter->WrapperConfigurationHandle = WrapperConfigurationContext;
 
    NdisInitializeWorkItem(&Adapter->ResetWorkItem, DcResetWorker, Adapter);
    NdisInitializeWorkItem(&Adapter->PowerWorkItem, DcPowerWorker, Adapter);
    NdisInitializeWorkItem(&Adapter->TxRecoveryWorkItem, DcTransmitTimeoutRecoveryWorker, Adapter);
 
    NdisMSetAttributesEx(MiniportAdapterHandle,
                         Adapter,
                         2, /* CheckForHangTimeInSeconds */
                         NDIS_ATTRIBUTE_BUS_MASTER |
                         NDIS_ATTRIBUTE_DESERIALIZE |
                         NDIS_ATTRIBUTE_USES_SAFE_BUFFER_APIS,
                         NdisInterfacePci);
 
    Status = DcRecognizeHardware(Adapter);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        return Status;
    }
 
    Status = DcInitializeAdapterResources(Adapter);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        goto Failure;
    }
 
    Status = DcInitializeAdapterLocation(Adapter);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        goto Failure;
    }
 
    /* Bring the chip out of sleep mode */
    DcPowerSave(Adapter, FALSE);
 
    OpMode = DC_READ(Adapter, DcCsr6_OpMode);
    OpMode &= ~(DC_OPMODE_RX_ENABLE | DC_OPMODE_TX_ENABLE);
    DC_WRITE(Adapter, DcCsr6_OpMode, OpMode);
 
    MediaInitMediaList(Adapter);
 
    Status = DcReadEeprom(Adapter);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        goto Failure;
    }
 
    NdisMoveMemory(Adapter->CurrentMacAddress, Adapter->PermanentMacAddress, ETH_LENGTH_OF_ADDRESS);
 
    Status = DcReadConfiguration(Adapter);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        goto Failure;
    }
 
    Status = DcAllocateMemory(Adapter);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        goto Failure;
    }
 
    DcInitTestPacket(Adapter);
 
    DcCreateRxRing(Adapter);
 
    /* Execute the reset sequence */
    if (Adapter->ResetStreamLength)
    {
        for (i = 0; i < Adapter->ResetStreamLength; ++i)
        {
            DcWriteGpio(Adapter, Adapter->ResetStream[i]);
            NdisMSleep(100);
        }
 
        /* Give the PHY some time to reset */
        NdisMSleep(5000);
    }
 
    /* Perform a software reset */
    DC_WRITE(Adapter, DcCsr0_BusMode, DC_BUS_MODE_SOFT_RESET);
    NdisMSleep(100);
    DC_WRITE(Adapter, DcCsr0_BusMode, Adapter->BusMode);
 
    /* Try to detect a MII PHY */
    if (Adapter->Features & DC_HAS_MII)
    {
        MediaSelectMiiPort(Adapter, TRUE);
 
        Success = DcFindMiiPhy(Adapter);
        if (Success)
        {
            /* Disable all link interrupts when the MII PHY media is found */
            Adapter->InterruptMask &= ~(DC_IRQ_LINK_CHANGED | DC_IRQ_LINK_FAIL | DC_IRQ_LINK_PASS);
            Adapter->LinkStateChangeMask = 0;
        }
        else
        {
            /* Incorrect EEPROM table or PHY is not connected, switch to a serial transceiver */
            WARN("No PHY devices found\n");
            Adapter->Features &= ~DC_HAS_MII;
        }
    }
 
    MediaInitDefaultMedia(Adapter, Adapter->DefaultMedia);
 
    /* Set the MAC address */
    DcSetupFrameInitialize(Adapter);
 
    /* Clear statistics */
    DC_READ(Adapter, DcCsr8_RxCounters);
 
    Adapter->Flags |= DC_FIRST_SETUP;
 
    Status = DcSetupAdapter(Adapter);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        ERR("Failed to initialize the NIC\n");
        goto Disable;
    }
 
    Adapter->Flags &= ~DC_FIRST_SETUP;
 
    Status = NdisMRegisterInterrupt(&Adapter->Interrupt,
                                    Adapter->AdapterHandle,
                                    Adapter->InterruptVector,
                                    Adapter->InterruptLevel,
                                    TRUE, /* Request ISR calls */
                                    !!(Adapter->Flags & DC_IRQ_SHARED),
                                    (Adapter->InterruptFlags & CM_RESOURCE_INTERRUPT_LATCHED) ?
                                    NdisInterruptLatched : NdisInterruptLevelSensitive);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        ERR("Unable to register interrupt\n");
        goto Disable;
    }
 
    DcStartAdapter(Adapter);
 
    return NDIS_STATUS_SUCCESS;
 
Disable:
    DcDisableHw(Adapter);
Failure:
    ERR("Initialization failed with status %08lx\n", Status);
 
    DcFreeAdapter(Adapter);
 
    return Status;
}

Referenced by DriverEntry().

DcInitRxRing()

VOID DcInitRxRing

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 574 of file init.c.

{
    PDC_RBD Rbd;
    ULONG i;
 
    PAGED_CODE();
 
    Rbd = Adapter->HeadRbd;
    Adapter->CurrentRbd = Rbd;
 
    for (i = 0; i < Adapter->RcbCount; ++i)
    {
        Rbd->Control = DC_RECEIVE_BUFFER_SIZE;
        Rbd->Status = DC_RBD_STATUS_OWNED;
 
        ++Rbd;
    }
    Rbd = Rbd - 1;
    Rbd->Control |= DC_RBD_CONTROL_CHAINED;
 
    ASSERT(Rbd == Adapter->TailRbd);
}

Referenced by DcSetupAdapter().

DcInitTxRing()

VOID DcInitTxRing

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 499 of file init.c.

{
    PDC_TCB Tcb;
    PDC_TBD Tbd;
 
    PAGED_CODE();
 
    InitializeListHead(&Adapter->SendQueueList);
 
    Tcb = Adapter->HeadTcb;
 
    Adapter->CurrentTcb = Tcb;
    Adapter->LastTcb = Tcb;
 
    Adapter->TcbSlots = DC_TRANSMIT_BLOCKS - DC_TCB_RESERVE;
    Adapter->TbdSlots = DC_TRANSMIT_DESCRIPTORS - DC_TBD_RESERVE;
    Adapter->LoopbackFrameSlots = DC_LOOPBACK_FRAMES;
    Adapter->TcbCompleted = 0;
 
    Tbd = Adapter->HeadTbd;
    Adapter->CurrentTbd = Tbd;
 
    NdisZeroMemory(Tbd, sizeof(*Tbd) * DC_TRANSMIT_DESCRIPTORS);
 
    Adapter->TailTbd->Control |= DC_TBD_CONTROL_END_OF_RING;
}

Referenced by DcSetupAdapter().

DcIsr()

VOID NTAPI DcIsr	(	_Out_ PBOOLEAN	InterruptRecognized,
		_Out_ PBOOLEAN	QueueMiniportHandleInterrupt,
		_In_ NDIS_HANDLE	MiniportAdapterContext
	)

Definition at line 594 of file interrupt.c.

{
    PDC21X4_ADAPTER Adapter = (PDC21X4_ADAPTER)MiniportAdapterContext;
    ULONG InterruptStatus;
 
    if (Adapter->CurrentInterruptMask == 0)
        goto NotOurs;
 
    InterruptStatus = DC_READ(Adapter, DcCsr5_Status);
    if (InterruptStatus == 0xFFFFFFFF || !(InterruptStatus & Adapter->CurrentInterruptMask))
        goto NotOurs;
 
    /* Disable further interrupts */
    DC_WRITE(Adapter, DcCsr7_IrqMask, 0);
 
    /* Clear all pending events */
    DC_WRITE(Adapter, DcCsr5_Status, InterruptStatus);
 
    Adapter->InterruptStatus = InterruptStatus;
    Adapter->CurrentInterruptMask = 0;
 
    *InterruptRecognized = TRUE;
    *QueueMiniportHandleInterrupt = TRUE;
    return;
 
NotOurs:
    *InterruptRecognized = FALSE;
    *QueueMiniportHandleInterrupt = FALSE;
}

Referenced by DriverEntry().

DcPowerSave()

VOID DcPowerSave	(	_In_ PDC21X4_ADAPTER	Adapter,
		_In_ BOOLEAN	Enable
	)

Definition at line 225 of file power.c.

{
    ULONG ConfigValue;
 
    if (!(Adapter->Features & DC_HAS_POWER_SAVING))
        return;
 
    NdisReadPciSlotInformation(Adapter->AdapterHandle,
                               0,
                               DC_PCI_DEVICE_CONFIG,
                               &ConfigValue,
                               sizeof(ConfigValue));
 
    ConfigValue &= ~DC_PCI_DEVICE_CONFIG_SLEEP;
 
    if (Enable)
        ConfigValue |= DC_PCI_DEVICE_CONFIG_SNOOZE;
    else
        ConfigValue &= ~DC_PCI_DEVICE_CONFIG_SNOOZE;
 
    NdisWritePciSlotInformation(Adapter->AdapterHandle,
                                0,
                                DC_PCI_DEVICE_CONFIG,
                                &ConfigValue,
                                sizeof(ConfigValue));
}

Referenced by DcDisableHw(), and DcInitialize().

DcPowerWorker()

VOID NTAPI DcPowerWorker	(	_In_ PNDIS_WORK_ITEM	WorkItem,
		_In_opt_ PVOID	Context
	)

Definition at line 167 of file power.c.

{
    PDC21X4_ADAPTER Adapter = Context;
 
    UNREFERENCED_PARAMETER(WorkItem);
 
    PAGED_CODE();
 
    if (Adapter->PowerState == NdisDeviceStateD0)
    {
        DcPowerUp(Adapter);
    }
    else
    {
        DcPowerDown(Adapter);
    }
    Adapter->PrevPowerState = Adapter->PowerState;
 
    NdisMSetInformationComplete(Adapter->AdapterHandle, NDIS_STATUS_SUCCESS);
}

Referenced by DcInitialize().

DcProcessPendingPackets()

VOID DcProcessPendingPackets

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 201 of file send.c.

{
    PLIST_ENTRY Entry;
    NDIS_STATUS Status;
    PNDIS_PACKET Packet;
 
    ASSERT(!IsListEmpty(&Adapter->SendQueueList));
 
    do
    {
        Entry = RemoveHeadList(&Adapter->SendQueueList);
 
        Packet = DC_PACKET_FROM_LIST_ENTRY(Entry);
 
        Status = DcSendPacket(Adapter, Packet);
        if (Status == NDIS_STATUS_RESOURCES)
        {
            InsertHeadList(&Adapter->SendQueueList, DC_LIST_ENTRY_FROM_PACKET(Packet));
            break;
        }
    }
    while (!IsListEmpty(&Adapter->SendQueueList));
}

Referenced by DcHandleTx().

DcQueryInformation()

NDIS_STATUS NTAPI DcQueryInformation	(	_In_ NDIS_HANDLE	MiniportAdapterContext,
		_In_ NDIS_OID	Oid,
		_In_ PVOID	InformationBuffer,
		_In_ ULONG	InformationBufferLength,
		_Out_ PULONG	BytesWritten,
		_Out_ PULONG	BytesNeeded
	)

Definition at line 208 of file requests.c.

{
    PDC21X4_ADAPTER Adapter = (PDC21X4_ADAPTER)MiniportAdapterContext;
    NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
    ULONG InfoLength;
    PVOID InfoPtr;
    union _GENERIC_INFORMATION
    {
        USHORT Ushort;
        ULONG Ulong;
        ULONG64 Ulong64;
        NDIS_MEDIUM Medium;
        NDIS_HARDWARE_STATUS Status;
        NDIS_DEVICE_POWER_STATE PowerState;
    } GenericInfo;
 
    InfoLength = sizeof(ULONG);
    InfoPtr = &GenericInfo;
 
    switch (Oid)
    {
        case OID_GEN_SUPPORTED_LIST:
            InfoPtr = (PVOID)&DcpSupportedOidList;
            InfoLength = sizeof(DcpSupportedOidList);
            break;
 
        case OID_GEN_CURRENT_PACKET_FILTER:
            GenericInfo.Ulong = Adapter->PacketFilter;
            break;
 
        case OID_802_3_MULTICAST_LIST:
            InfoPtr = Adapter->MulticastList;
            InfoLength = Adapter->MulticastCount * ETH_LENGTH_OF_ADDRESS;
            break;
 
        case OID_802_3_MAXIMUM_LIST_SIZE:
            GenericInfo.Ulong = Adapter->MulticastMaxEntries;
            break;
 
        case OID_GEN_MEDIA_SUPPORTED:
        case OID_GEN_MEDIA_IN_USE:
        {
            GenericInfo.Medium = NdisMedium802_3;
            InfoLength = sizeof(NDIS_MEDIUM);
            break;
        }
 
        case OID_GEN_HARDWARE_STATUS:
        {
            ULONG InterruptStatus;
 
            /* NOTE: Reading the status register has no effect on the events */
            InterruptStatus = DC_READ(Adapter, DcCsr5_Status);
 
            /* Inserted into the motherboard */
            if (InterruptStatus != 0xFFFFFFFF)
                GenericInfo.Status = NdisHardwareStatusReady;
            else
                GenericInfo.Status = NdisHardwareStatusNotReady;
 
            InfoLength = sizeof(NDIS_HARDWARE_STATUS);
            break;
        }
 
        case OID_GEN_MAXIMUM_FRAME_SIZE:
        case OID_GEN_MAXIMUM_LOOKAHEAD:
        case OID_GEN_CURRENT_LOOKAHEAD:
            GenericInfo.Ulong = DC_MAXIMUM_FRAME_SIZE - DC_ETHERNET_HEADER_SIZE;
            break;
 
        case OID_GEN_MAXIMUM_TOTAL_SIZE:
            GenericInfo.Ulong = DC_MAXIMUM_FRAME_SIZE;
            break;
 
        case OID_GEN_TRANSMIT_BLOCK_SIZE:
            GenericInfo.Ulong = DC_TRANSMIT_BLOCK_SIZE;
            break;
 
        case OID_GEN_TRANSMIT_BUFFER_SPACE:
            GenericInfo.Ulong = DC_TRANSMIT_BLOCK_SIZE * DC_TRANSMIT_BLOCKS;
            break;
 
        case OID_GEN_RECEIVE_BLOCK_SIZE:
            GenericInfo.Ulong = DC_RECEIVE_BLOCK_SIZE;
            break;
 
        case OID_GEN_RECEIVE_BUFFER_SPACE:
            GenericInfo.Ulong = DC_RECEIVE_BLOCK_SIZE * Adapter->RcbCount;
            break;
 
        case OID_GEN_LINK_SPEED:
            GenericInfo.Ulong = DcGetLinkSpeed(Adapter) * 10000;
            break;
 
        case OID_GEN_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 const CHAR VendorDesc[] = "DC21x4 compatible Ethernet Adapter";
            InfoPtr = (PVOID)&VendorDesc;
            InfoLength = sizeof(VendorDesc);
            break;
        }
 
        case OID_GEN_VENDOR_DRIVER_VERSION:
            /* 1.0.0 */
            GenericInfo.Ulong = 0x100;
            break;
 
        case OID_GEN_DRIVER_VERSION:
        {
            InfoLength = sizeof(USHORT);
            GenericInfo.Ushort = (NDIS_MINIPORT_MAJOR_VERSION << 8) | NDIS_MINIPORT_MINOR_VERSION;
            break;
        }
 
        case OID_GEN_MAXIMUM_SEND_PACKETS:
            GenericInfo.Ulong = DC_TRANSMIT_BLOCKS - DC_TCB_RESERVE;
            break;
 
        case OID_GEN_MAC_OPTIONS:
            GenericInfo.Ulong = 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->LinkUp ? NdisMediaStateConnected
                                                : NdisMediaStateDisconnected;
            break;
 
        case OID_802_3_PERMANENT_ADDRESS:
            InfoPtr = Adapter->PermanentMacAddress;
            InfoLength = ETH_LENGTH_OF_ADDRESS;
            break;
 
        case OID_802_3_CURRENT_ADDRESS:
            InfoPtr = Adapter->CurrentMacAddress;
            InfoLength = ETH_LENGTH_OF_ADDRESS;
            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:
        case OID_GEN_DIRECTED_FRAMES_RCV:
        case OID_GEN_MULTICAST_FRAMES_RCV:
        case OID_GEN_BROADCAST_FRAMES_RCV:
        case OID_GEN_RCV_CRC_ERROR:
        case OID_802_3_RCV_ERROR_ALIGNMENT:
        case OID_802_3_XMIT_ONE_COLLISION:
        case OID_802_3_XMIT_MORE_COLLISIONS:
        case OID_802_3_XMIT_DEFERRED:
        case OID_802_3_XMIT_MAX_COLLISIONS:
        case OID_802_3_RCV_OVERRUN:
        case OID_802_3_XMIT_UNDERRUN:
        case OID_802_3_XMIT_HEARTBEAT_FAILURE:
        case OID_802_3_XMIT_TIMES_CRS_LOST:
        case OID_802_3_XMIT_LATE_COLLISIONS:
        {
            DcQueryStatisticCounter(Adapter, Oid, &GenericInfo.Ulong64);
 
            *BytesNeeded = sizeof(ULONG64);
            if (InformationBufferLength < sizeof(ULONG))
            {
                *BytesWritten = 0;
                return NDIS_STATUS_BUFFER_TOO_SHORT;
            }
            if (InformationBufferLength >= sizeof(ULONG64))
            {
                *BytesWritten = sizeof(ULONG64);
                NdisMoveMemory(InformationBuffer, InfoPtr, sizeof(ULONG64));
            }
            else
            {
                *BytesWritten = sizeof(ULONG);
                NdisMoveMemory(InformationBuffer, InfoPtr, sizeof(ULONG));
            }
 
            return NDIS_STATUS_SUCCESS;
        }
 
        case OID_GEN_TRANSMIT_QUEUE_LENGTH:
            GenericInfo.Ulong = (DC_TRANSMIT_BLOCKS - DC_TCB_RESERVE) - Adapter->TcbSlots;
            break;
 
        case OID_PNP_CAPABILITIES:
        {
            PNDIS_PNP_CAPABILITIES Capabilities;
 
            InfoLength = sizeof(NDIS_PNP_CAPABILITIES);
 
            if (InformationBufferLength < InfoLength)
            {
                *BytesWritten = 0;
                *BytesNeeded = InfoLength;
                return NDIS_STATUS_BUFFER_TOO_SHORT;
            }
 
            if (!(Adapter->Features & DC_HAS_POWER_MANAGEMENT))
                return NDIS_STATUS_NOT_SUPPORTED;
 
            *BytesWritten = InfoLength;
            *BytesNeeded = 0;
 
            Capabilities = InformationBuffer;
            Capabilities->WakeUpCapabilities.MinMagicPacketWakeUp = NdisDeviceStateD3;
            Capabilities->WakeUpCapabilities.MinPatternWakeUp = NdisDeviceStateD3;
            Capabilities->WakeUpCapabilities.MinLinkChangeWakeUp = NdisDeviceStateD3;
 
            return NDIS_STATUS_SUCCESS;
        }
 
        case OID_PNP_QUERY_POWER:
        {
            if (!(Adapter->Features & DC_HAS_POWER_MANAGEMENT))
                return NDIS_STATUS_NOT_SUPPORTED;
 
            return NDIS_STATUS_SUCCESS;
        }
 
        case OID_PNP_ENABLE_WAKE_UP:
        {
            if (!(Adapter->Features & DC_HAS_POWER_MANAGEMENT))
                return NDIS_STATUS_NOT_SUPPORTED;
 
            GenericInfo.Ulong = Adapter->WakeUpFlags & (NDIS_PNP_WAKE_UP_MAGIC_PACKET |
                                                        NDIS_PNP_WAKE_UP_PATTERN_MATCH |
                                                        NDIS_PNP_WAKE_UP_LINK_CHANGE);
            break;
        }
 
        default:
            Status = NDIS_STATUS_INVALID_OID;
            break;
    }
 
    if (Status == NDIS_STATUS_SUCCESS)
    {
        if (InfoLength > InformationBufferLength)
        {
            *BytesWritten = 0;
            *BytesNeeded = InfoLength;
            Status = NDIS_STATUS_BUFFER_TOO_SHORT;
        }
        else
        {
            NdisMoveMemory(InformationBuffer, InfoPtr, InfoLength);
            *BytesWritten = InfoLength;
            *BytesNeeded = 0;
        }
    }
    else
    {
        *BytesWritten = 0;
        *BytesNeeded = 0;
    }
 
    return Status;
}

Referenced by DriverEntry().

DcReadEeprom()

NDIS_STATUS DcReadEeprom

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 1482 of file eeprom.c.

{
    NDIS_STATUS Status;
 
    PAGED_CODE();
 
    if (Adapter->ChipType == DC21040)
    {
        /* Ethernet Address ROM */
        Status = AddressRomRead(Adapter);
    }
    else
    {
        /* MicroWire Compatible Serial EEPROM */
        Status = SRomRead(Adapter);
    }
 
    if (Status != NDIS_STATUS_SUCCESS)
        return Status;
 
    INFO("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]);
 
    if (ETH_IS_BROADCAST(Adapter->PermanentMacAddress) ||
        ETH_IS_EMPTY(Adapter->PermanentMacAddress) ||
        ETH_IS_MULTICAST(Adapter->PermanentMacAddress))
    {
        ERR("Invalid permanent MAC address %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]);
 
        NdisWriteErrorLogEntry(Adapter->AdapterHandle, NDIS_ERROR_CODE_NETWORK_ADDRESS, 0);
 
        return NDIS_STATUS_INVALID_ADDRESS;
    }
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by DcInitialize().

DcRemoveWakeUpPattern()

NDIS_STATUS DcRemoveWakeUpPattern	(	_In_ PDC21X4_ADAPTER	Adapter,
		_In_ PNDIS_PM_PACKET_PATTERN	PmPattern
	)

Definition at line 205 of file power.c.

{
    // TODO: Not implemented
    ERR("FIXME: Not implemented\n");
    return NDIS_STATUS_NOT_SUPPORTED;
}

Referenced by DcSetInformation().

DcResetWorker()

VOID NTAPI DcResetWorker	(	_In_ PNDIS_WORK_ITEM	WorkItem,
		_In_opt_ PVOID	Context
	)

Definition at line 190 of file dc21x4.c.

{
    PDC21X4_ADAPTER Adapter = Context;
    NDIS_STATUS Status;
    ULONG InterruptStatus;
    LONG ResetReason;
 
    UNREFERENCED_PARAMETER(WorkItem);
 
    PAGED_CODE();
 
    Status = NDIS_STATUS_SUCCESS;
 
    /* Check if the device is present */
    InterruptStatus = DC_READ(Adapter, DcCsr5_Status);
    if (InterruptStatus == 0xFFFFFFFF)
    {
        ERR("Hardware is gone...\n");
 
        /* Remove this adapter */
        NdisMRemoveMiniport(Adapter->AdapterHandle);
 
        Status = NDIS_STATUS_HARD_ERRORS;
        goto Done;
    }
 
    DcStopAdapter(Adapter, FALSE);
 
    if (Adapter->LinkUp)
    {
        Adapter->LinkUp = FALSE;
 
        NdisMIndicateStatus(Adapter->AdapterHandle,
                            NDIS_STATUS_MEDIA_DISCONNECT,
                            NULL,
                            0);
        NdisMIndicateStatusComplete(Adapter->AdapterHandle);
    }
 
    DcSetupAdapter(Adapter);
 
    DcStartAdapter(Adapter);
 
Done:
    ResetReason = _InterlockedExchange(&Adapter->ResetLock, 0);
 
    /* Complete the pending reset request */
    if (ResetReason == 1)
    {
        NdisMResetComplete(Adapter->AdapterHandle, Status, FALSE);
    }
}

Referenced by DcInitialize().

DcReturnPacket()

VOID NTAPI DcReturnPacket	(	_In_ NDIS_HANDLE	MiniportAdapterContext,
		_In_ PNDIS_PACKET	Packet
	)

Definition at line 244 of file interrupt.c.

{
    PDC21X4_ADAPTER Adapter = (PDC21X4_ADAPTER)MiniportAdapterContext;
    PDC_RCB Rcb;
 
    Rcb = *DC_RCB_FROM_PACKET(Packet);
 
    NdisAcquireSpinLock(&Adapter->ReceiveLock);
 
    PushEntryList(&Adapter->FreeRcbList, &Rcb->ListEntry);
 
    ++Adapter->RcbFree;
 
    NdisReleaseSpinLock(&Adapter->ReceiveLock);
}

Referenced by DriverEntry().

DcSendPackets()

VOID NTAPI DcSendPackets	(	_In_ NDIS_HANDLE	MiniportAdapterContext,
		_In_ PPNDIS_PACKET	PacketArray,
		_In_ UINT	NumberOfPackets
	)

Definition at line 228 of file send.c.

{
    PDC21X4_ADAPTER Adapter = (PDC21X4_ADAPTER)MiniportAdapterContext;
    NDIS_STATUS Status;
    ULONG i;
 
    NdisAcquireSpinLock(&Adapter->SendLock);
 
    if (!(Adapter->Flags & DC_ACTIVE))
    {
        NdisReleaseSpinLock(&Adapter->SendLock);
 
        for (i = 0; i < NumberOfPackets; ++i)
        {
            NdisMSendComplete(Adapter->AdapterHandle,
                              PacketArray[i],
                              NDIS_STATUS_NOT_ACCEPTED);
        }
 
        return;
    }
 
    TRACE("Send packets %u\n", NumberOfPackets);
 
    for (i = 0; i < NumberOfPackets; ++i)
    {
        PNDIS_PACKET Packet = PacketArray[i];
 
        Status = DcSendPacket(Adapter, Packet);
        if (Status == NDIS_STATUS_RESOURCES)
        {
            InsertTailList(&Adapter->SendQueueList, DC_LIST_ENTRY_FROM_PACKET(Packet));
        }
    }
 
    NdisReleaseSpinLock(&Adapter->SendLock);
}

Referenced by DriverEntry().

DcSetInformation()

NDIS_STATUS NTAPI DcSetInformation	(	_In_ NDIS_HANDLE	MiniportAdapterContext,
		_In_ NDIS_OID	Oid,
		_In_ PVOID	InformationBuffer,
		_In_ ULONG	InformationBufferLength,
		_Out_ PULONG	BytesRead,
		_Out_ PULONG	BytesNeeded
	)

Definition at line 483 of file requests.c.

{
    PDC21X4_ADAPTER Adapter = (PDC21X4_ADAPTER)MiniportAdapterContext;
    NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
    ULONG GenericUlong;
 
    *BytesRead = 0;
    *BytesNeeded = 0;
 
    switch (Oid)
    {
        case OID_GEN_CURRENT_PACKET_FILTER:
        {
            if (InformationBufferLength < sizeof(ULONG))
            {
                *BytesNeeded = sizeof(ULONG);
                Status = NDIS_STATUS_INVALID_LENGTH;
                break;
            }
 
            *BytesRead = sizeof(ULONG);
            NdisMoveMemory(&GenericUlong, InformationBuffer, sizeof(ULONG));
 
            if (GenericUlong & ~DC_PACKET_FILTERS)
            {
                Status = NDIS_STATUS_NOT_SUPPORTED;
                break;
            }
 
            Status = DcApplyPacketFilter(Adapter, GenericUlong);
            break;
        }
 
        case OID_802_3_MULTICAST_LIST:
        {
            ULONG Size;
 
            if (InformationBufferLength % ETH_LENGTH_OF_ADDRESS)
            {
                *BytesNeeded = (InformationBufferLength / ETH_LENGTH_OF_ADDRESS) *
                               ETH_LENGTH_OF_ADDRESS;
                Status = NDIS_STATUS_INVALID_LENGTH;
                break;
            }
 
            Size = Adapter->MulticastMaxEntries * ETH_LENGTH_OF_ADDRESS;
            if (InformationBufferLength > Size)
            {
                *BytesNeeded = Size;
                Status = NDIS_STATUS_MULTICAST_FULL;
                break;
            }
 
            *BytesRead = InformationBufferLength;
            NdisMoveMemory(Adapter->MulticastList, InformationBuffer, InformationBufferLength);
 
            Adapter->MulticastCount = InformationBufferLength / ETH_LENGTH_OF_ADDRESS;
 
            Status = DcUpdateMulticastList(Adapter);
            break;
        }
 
        case OID_GEN_CURRENT_LOOKAHEAD:
        {
            if (InformationBufferLength < sizeof(ULONG))
            {
                *BytesNeeded = sizeof(ULONG);
                Status = NDIS_STATUS_INVALID_LENGTH;
                break;
            }
 
            /* Nothing to do */
            *BytesRead = sizeof(ULONG);
            break;
        }
 
        case OID_PNP_ENABLE_WAKE_UP:
        {
            if (InformationBufferLength < sizeof(ULONG))
            {
                *BytesNeeded = sizeof(ULONG);
                Status = NDIS_STATUS_INVALID_LENGTH;
                break;
            }
 
            if (!(Adapter->Features & DC_HAS_POWER_MANAGEMENT))
            {
                return NDIS_STATUS_NOT_SUPPORTED;
            }
 
            *BytesRead = sizeof(ULONG);
            NdisMoveMemory(&GenericUlong, InformationBuffer, sizeof(ULONG));
 
            Adapter->WakeUpFlags = GenericUlong;
            break;
        }
 
        case OID_PNP_ADD_WAKE_UP_PATTERN:
        {
            if (InformationBufferLength < sizeof(NDIS_PM_PACKET_PATTERN))
            {
                *BytesNeeded = sizeof(NDIS_PM_PACKET_PATTERN);
                Status = NDIS_STATUS_INVALID_LENGTH;
                break;
            }
 
            if (!(Adapter->Features & DC_HAS_POWER_MANAGEMENT))
            {
                return NDIS_STATUS_NOT_SUPPORTED;
            }
 
            *BytesRead = sizeof(NDIS_PM_PACKET_PATTERN);
 
            Status = DcAddWakeUpPattern(Adapter, InformationBuffer);
            break;
        }
 
        case OID_PNP_REMOVE_WAKE_UP_PATTERN:
        {
            if (InformationBufferLength < sizeof(NDIS_PM_PACKET_PATTERN))
            {
                *BytesNeeded = sizeof(NDIS_PM_PACKET_PATTERN);
                Status = NDIS_STATUS_INVALID_LENGTH;
                break;
            }
 
            if (!(Adapter->Features & DC_HAS_POWER_MANAGEMENT))
            {
                return NDIS_STATUS_NOT_SUPPORTED;
            }
 
            *BytesRead = sizeof(NDIS_PM_PACKET_PATTERN);
 
            Status = DcRemoveWakeUpPattern(Adapter, InformationBuffer);
            break;
        }
 
        case OID_PNP_SET_POWER:
        {
            if (InformationBufferLength < sizeof(NDIS_DEVICE_POWER_STATE))
            {
                *BytesNeeded = sizeof(NDIS_DEVICE_POWER_STATE);
                Status = NDIS_STATUS_INVALID_LENGTH;
                break;
            }
 
            if (!(Adapter->Features & DC_HAS_POWER_MANAGEMENT))
            {
                return NDIS_STATUS_NOT_SUPPORTED;
            }
 
            *BytesRead = sizeof(ULONG);
            NdisMoveMemory(&GenericUlong, InformationBuffer, sizeof(ULONG));
 
            if (GenericUlong < NdisDeviceStateD0 || GenericUlong > NdisDeviceStateD3)
            {
                ASSERT(FALSE);
                Status = NDIS_STATUS_INVALID_DATA;
                break;
            }
 
            DcSetPower(Adapter, GenericUlong);
            break;
        }
 
        default:
            Status = NDIS_STATUS_NOT_SUPPORTED;
            break;
    }
 
    return Status;
}

Referenced by DriverEntry().

DcSetPower()

NDIS_STATUS DcSetPower	(	_In_ PDC21X4_ADAPTER	Adapter,
		_In_ NDIS_DEVICE_POWER_STATE	PowerState
	)

Definition at line 191 of file power.c.

{
    INFO("Power state %u\n", PowerState);
 
    Adapter->PowerState = PowerState;
 
    NdisScheduleWorkItem(&Adapter->PowerWorkItem);
 
    return NDIS_STATUS_PENDING;
}

Referenced by DcSetInformation().

DcSetupAdapter()

NDIS_STATUS DcSetupAdapter

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 462 of file hardware.c.

{
    PAGED_CODE();
 
    DcInitTxRing(Adapter);
    DcInitRxRing(Adapter);
 
    /* Initial values */
    if (!MEDIA_IS_FIXED(Adapter))
    {
        Adapter->LinkSpeedMbps = 10;
    }
    Adapter->MediaNumber = Adapter->DefaultMedia;
    Adapter->ModeFlags &= ~(DC_MODE_PORT_AUTOSENSE | DC_MODE_AUI_FAILED | DC_MODE_BNC_FAILED |
                            DC_MODE_TEST_PACKET | DC_MODE_AUTONEG_MASK);
 
    DcSoftReset(Adapter);
 
    /* Receive descriptor ring buffer */
    DC_WRITE(Adapter, DcCsr3_RxRingAddress, Adapter->RbdPhys);
 
    /* Transmit descriptor ring buffer */
    DC_WRITE(Adapter, DcCsr4_TxRingAddress, Adapter->TbdPhys);
 
    switch (Adapter->ChipType)
    {
        case DC21040:
        {
            DcWriteSia(Adapter,
                       Adapter->Media[Adapter->MediaNumber].Csr13,
                       Adapter->Media[Adapter->MediaNumber].Csr14,
                       Adapter->Media[Adapter->MediaNumber].Csr15);
 
            /* Explicitly specifed by user */
            if (Adapter->MediaNumber == MEDIA_10T_FD)
            {
                Adapter->OpMode |= DC_OPMODE_FULL_DUPLEX;
            }
            break;
        }
 
        case DC21041:
        {
            MediaSiaSelect(Adapter);
            break;
        }
 
        case DC21140:
        {
            if (Adapter->MediaNumber == MEDIA_MII)
            {
                MediaSelectMiiPort(Adapter, !(Adapter->Flags & DC_FIRST_SETUP));
                MediaMiiSelect(Adapter);
            }
            else
            {
                /* All media use the same GPIO directon */
                DC_WRITE(Adapter, DcCsr12_Gpio, Adapter->Media[Adapter->MediaNumber].GpioCtrl);
                NdisStallExecution(10);
 
                MediaGprSelect(Adapter);
            }
            break;
        }
 
        case DC21143:
        case DC21145:
        {
            /* Init the HPNA PHY */
            if ((Adapter->MediaBitmap & (1 << MEDIA_HMR)) && Adapter->HpnaInitBitmap)
            {
                HpnaPhyInit(Adapter);
            }
 
            if (Adapter->MediaNumber == MEDIA_MII)
            {
                MediaSelectMiiPort(Adapter, !(Adapter->Flags & DC_FIRST_SETUP));
                MediaMiiSelect(Adapter);
                break;
            }
 
            /* If the current media is FX, assume we have a link */
            if (MEDIA_IS_FX(Adapter->MediaNumber))
            {
                Adapter->LinkUp = TRUE;
 
                NdisMIndicateStatus(Adapter->AdapterHandle,
                                    NDIS_STATUS_MEDIA_CONNECT,
                                    NULL,
                                    0);
                NdisMIndicateStatusComplete(Adapter->AdapterHandle);
            }
 
            MediaSiaSelect(Adapter);
            break;
        }
 
        default:
            ASSERT(FALSE);
            UNREACHABLE;
            break;
    }
 
    /* Start the TX process */
    Adapter->OpMode |= DC_OPMODE_TX_ENABLE;
    DC_WRITE(Adapter, DcCsr6_OpMode, Adapter->OpMode);
 
    /* Load the address recognition RAM */
    if (!DcSetupFrameDownload(Adapter, TRUE))
    {
        /* This normally should not happen */
        ASSERT(FALSE);
 
        NdisWriteErrorLogEntry(Adapter->AdapterHandle,
                               NDIS_ERROR_CODE_HARDWARE_FAILURE,
                               1,
                               __LINE__);
 
        return NDIS_STATUS_HARD_ERRORS;
    }
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by DcInitialize(), DcPowerUp(), and DcResetWorker().

DcSetupFrameDownload()

BOOLEAN DcSetupFrameDownload	(	_In_ PDC21X4_ADAPTER	Adapter,
		_In_ BOOLEAN	WaitForCompletion
	)

Definition at line 187 of file hardware.c.

{
    PDC_TCB Tcb;
    PDC_TBD Tbd;
    ULONG i, Control;
 
    Tbd = Adapter->CurrentTbd;
 
    /* Ensure correct setup frame processing */
    if (Tbd != Adapter->HeadTbd)
    {
        ASSERT(!(Tbd->Status & DC_TBD_STATUS_OWNED));
 
        /* Put the null frame on the transmit ring */
        Tbd->Control &= DC_TBD_CONTROL_END_OF_RING;
        Tbd->Address1 = 0;
        Tbd->Address2 = 0;
        DC_WRITE_BARRIER();
        Tbd->Status = DC_TBD_STATUS_OWNED;
 
        Tbd = DC_NEXT_TBD(Adapter, Tbd);
    }
 
    Adapter->CurrentTbd = DC_NEXT_TBD(Adapter, Tbd);
 
    Tcb = Adapter->CurrentTcb;
    Adapter->CurrentTcb = DC_NEXT_TCB(Adapter, Tcb);
 
    Tcb->Tbd = Tbd;
    Tcb->Packet = NULL;
 
    ASSERT(!(Tbd->Status & DC_TBD_STATUS_OWNED));
 
    /* Prepare the setup frame */
    Tbd->Address1 = Adapter->SetupFramePhys;
    Tbd->Address2 = 0;
    Tbd->Control &= DC_TBD_CONTROL_END_OF_RING;
    Control = DC_SETUP_FRAME_SIZE | DC_TBD_CONTROL_SETUP_FRAME;
    if (!WaitForCompletion)
        Control |= DC_TBD_CONTROL_REQUEST_INTERRUPT;
    if (Adapter->ProgramHashPerfectFilter)
        Control |= DC_TBD_CONTROL_HASH_PERFECT_FILTER;
    Tbd->Control |= Control;
    DC_WRITE_BARRIER();
    Tbd->Status = DC_TBD_STATUS_OWNED;
 
    DC_WRITE(Adapter, DcCsr1_TxPoll, DC_TX_POLL_DOORBELL);
 
    if (!WaitForCompletion)
        return TRUE;
 
    /* Wait up to 500 ms for the chip to process the setup frame */
    for (i = 50000; i > 0; --i)
    {
        NdisStallExecution(10);
 
        KeMemoryBarrierWithoutFence();
        if (!(Tbd->Status & DC_TBD_STATUS_OWNED))
            break;
    }
    if (i == 0)
    {
        ERR("Failed to complete setup frame %08lx\n", Tbd->Status);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by DcPowerUp(), DcSetupAdapter(), and DcUpdateMulticastList().

DcSetupFrameInitialize()

VOID DcSetupFrameInitialize

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 260 of file hardware.c.

{
    PULONG SetupFrame, SetupFrameStart;
    PUSHORT MacAddress;
    ULONG i;
 
    PAGED_CODE();
 
    SetupFrame = Adapter->SetupFrame;
 
    /* Add the physical address entry */
    MacAddress = (PUSHORT)Adapter->CurrentMacAddress;
    *SetupFrame++ = DC_SETUP_FRAME_ENTRY(MacAddress[0]);
    *SetupFrame++ = DC_SETUP_FRAME_ENTRY(MacAddress[1]);
    *SetupFrame++ = DC_SETUP_FRAME_ENTRY(MacAddress[2]);
 
    /* Pad to 16 addresses */
    SetupFrameStart = Adapter->SetupFrame;
    for (i = 1; i < DC_SETUP_FRAME_PERFECT_FILTER_ADDRESSES; ++i)
    {
        *SetupFrame++ = SetupFrameStart[0];
        *SetupFrame++ = SetupFrameStart[1];
        *SetupFrame++ = SetupFrameStart[2];
    }
}

Referenced by DcInitialize().

DcStartAdapter()

VOID DcStartAdapter

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 168 of file dc21x4.c.

{
    PAGED_CODE();
 
    /* Enable interrupts */
    _InterlockedExchange((PLONG)&Adapter->CurrentInterruptMask, Adapter->InterruptMask);
    DC_WRITE(Adapter, DcCsr7_IrqMask, Adapter->InterruptMask);
 
    Adapter->Flags |= DC_ACTIVE;
 
    /* Start the RX process */
    Adapter->OpMode |= DC_OPMODE_RX_ENABLE;
    DC_WRITE(Adapter, DcCsr6_OpMode, Adapter->OpMode);
 
    /* Start the media monitor, wait the selected media to become ready */
    NdisMSetTimer(&Adapter->MediaMonitorTimer, 2400);
}

Referenced by DcInitialize(), DcPowerUp(), and DcResetWorker().

DcStopAdapter()

DECLSPEC_NOINLINE VOID DcStopAdapter	(	_In_ PDC21X4_ADAPTER	Adapter,
		_In_ BOOLEAN	WaitForPackets
	)

Definition at line 123 of file dc21x4.c.

{
    BOOLEAN TimerCancelled;
 
    /* Attempt to disable interrupts to complete more quickly */
    DC_WRITE(Adapter, DcCsr7_IrqMask, 0);
 
    /* Prevent DPCs from executing and stop accepting incoming packets */
    NdisAcquireSpinLock(&Adapter->SendLock);
    Adapter->Flags &= ~DC_ACTIVE;
    NdisReleaseSpinLock(&Adapter->SendLock);
 
    NdisMCancelTimer(&Adapter->MediaMonitorTimer, &TimerCancelled);
 
    /* Wait for any DPCs to complete */
    KeFlushQueuedDpcs();
 
    /* Disable interrupts */
    DC_WRITE(Adapter, DcCsr7_IrqMask, 0);
 
    /* Wait for completion of TX/RX and stop the DMA engine inside the NIC */
    DcStopTxRxProcess(Adapter);
    Adapter->OpMode &= ~(DC_OPMODE_RX_ENABLE | DC_OPMODE_TX_ENABLE);
 
    DcFlushTransmitQueue(Adapter);
 
    /* Wait for the packets to be returned to the driver */
    if (WaitForPackets)
    {
        DcStopReceivePath(Adapter);
    }
 
    /* Make sure there is no pending OID request */
    if (Adapter->OidPending)
    {
        NdisMSetInformationComplete(Adapter->AdapterHandle, NDIS_STATUS_SUCCESS);
 
        Adapter->OidPending = FALSE;
    }
}

Referenced by DcHalt(), DcPowerDown(), and DcResetWorker().

DcStopTxRxProcess()

VOID DcStopTxRxProcess

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 38 of file hardware.c.

{
    ULONG i, OpMode, Status;
 
    OpMode = Adapter->OpMode;
    OpMode &= ~(DC_OPMODE_RX_ENABLE | DC_OPMODE_TX_ENABLE);
    DC_WRITE(Adapter, DcCsr6_OpMode, OpMode);
 
    for (i = 0; i < 5000; ++i)
    {
        Status = DC_READ(Adapter, DcCsr5_Status);
 
        if (((Status & DC_STATUS_TX_STATE_MASK) == DC_STATUS_TX_STATE_STOPPED) &&
            ((Status & DC_STATUS_RX_STATE_MASK) == DC_STATUS_RX_STATE_STOPPED))
        {
            return;
        }
 
        NdisStallExecution(10);
    }
 
    WARN("Failed to stop the TX/RX process 0x%08lx\n", Status);
}

Referenced by DcAdjustTxFifoThreshold(), DcStopAdapter(), DcTransmitTimeoutRecoveryWorker(), Media143SelectNextSerialMedia(), MediaMiiSetSpeedAndDuplex(), and MediaSiaSelect().

DcTestPacket()

VOID DcTestPacket

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 135 of file hardware.c.

{
    PDC_TCB Tcb;
    PDC_TBD Tbd;
    ULONG FrameNumber;
 
    Adapter->MediaTestStatus = FALSE;
    Adapter->ModeFlags |= DC_MODE_TEST_PACKET;
 
    if (!Adapter->LoopbackFrameSlots)
    {
        ERR("Failed to complete test packets, CSR12 %08lx, CSR5 %08lx\n",
            DC_READ(Adapter, DcCsr12_SiaStatus),
            DC_READ(Adapter, DcCsr5_Status));
 
        /* Try to recover the lost TX buffers */
        NdisScheduleWorkItem(&Adapter->TxRecoveryWorkItem);
        return;
    }
 
    --Adapter->LoopbackFrameSlots;
 
    FrameNumber = (Adapter->LoopbackFrameNumber++) % DC_LOOPBACK_FRAMES;
 
    Tbd = Adapter->CurrentTbd;
    Adapter->CurrentTbd = DC_NEXT_TBD(Adapter, Tbd);
 
    Tcb = Adapter->CurrentTcb;
    Adapter->CurrentTcb = DC_NEXT_TCB(Adapter, Tcb);
 
    Tcb->Tbd = Tbd;
    Tcb->Packet = NULL;
 
    ASSERT(!(Tbd->Status & DC_TBD_STATUS_OWNED));
 
    /* Put the loopback frame on the transmit ring */
    Tbd->Address1 = Adapter->LoopbackFramePhys[FrameNumber];
    Tbd->Address2 = 0;
    Tbd->Control &= DC_TBD_CONTROL_END_OF_RING;
    Tbd->Control |= DC_LOOPBACK_FRAME_SIZE |
                    DC_TBD_CONTROL_FIRST_FRAGMENT |
                    DC_TBD_CONTROL_LAST_FRAGMENT |
                    DC_TBD_CONTROL_REQUEST_INTERRUPT;
    DC_WRITE_BARRIER();
    Tbd->Status = DC_TBD_STATUS_OWNED;
 
    /* Send the loopback packet to verify connectivity of a media */
    DC_WRITE(Adapter, DcCsr1_TxPoll, DC_TX_POLL_DOORBELL);
}

Referenced by MediaMonitor21040Dpc(), MediaMonitor21041Dpc(), and MediaMonitor21143Dpc().

DcTransmitTimeoutRecoveryWorker()

VOID NTAPI DcTransmitTimeoutRecoveryWorker	(	_In_ PNDIS_WORK_ITEM	WorkItem,
		_In_opt_ PVOID	Context
	)

Definition at line 247 of file dc21x4.c.

{
    PDC21X4_ADAPTER Adapter = Context;
 
    UNREFERENCED_PARAMETER(WorkItem);
 
    NdisAcquireSpinLock(&Adapter->ModeLock);
 
    DcStopTxRxProcess(Adapter);
    DC_WRITE(Adapter, DcCsr6_OpMode, Adapter->OpMode);
 
    NdisDprAcquireSpinLock(&Adapter->SendLock);
 
    DC_WRITE(Adapter, DcCsr1_TxPoll, DC_TX_POLL_DOORBELL);
 
    NdisDprReleaseSpinLock(&Adapter->SendLock);
 
    NdisReleaseSpinLock(&Adapter->ModeLock);
}

Referenced by DcInitialize().

DcUpdateMulticastList()

NDIS_STATUS DcUpdateMulticastList

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 375 of file hardware.c.

{
    BOOLEAN UsePerfectFiltering;
 
    /* If more than 14 addresses are requested, switch to hash filtering mode */
    UsePerfectFiltering = (Adapter->MulticastCount <= DC_SETUP_FRAME_ADDRESSES);
 
    Adapter->ProgramHashPerfectFilter = UsePerfectFiltering;
    Adapter->OidPending = TRUE;
 
    if (UsePerfectFiltering)
        DcSetupFramePerfectFiltering(Adapter);
    else
        DcSetupFrameImperfectFiltering(Adapter);
 
    NdisAcquireSpinLock(&Adapter->SendLock);
 
    DcSetupFrameDownload(Adapter, FALSE);
 
    NdisReleaseSpinLock(&Adapter->SendLock);
 
    return NDIS_STATUS_PENDING;
}

Referenced by DcApplyPacketFilter(), and DcSetInformation().

DcWriteGpio()

VOID DcWriteGpio	(	_In_ PDC21X4_ADAPTER	Adapter,
		_In_ ULONG	Value
	)

Definition at line 64 of file hardware.c.

{
    ULONG Data, Register;
 
    /* Some chips don't have a separate GPIO register */
    if (Adapter->Features & DC_SIA_GPIO)
    {
        Data = Adapter->SiaSetting;
        Data &= 0x0000FFFF;  /* SIA */
        Data |= Value << 16; /* GPIO */
        Adapter->SiaSetting = Data;
 
        Register = DcCsr15_SiaGeneral;
    }
    else
    {
        Data = Value;
        Register = DcCsr12_Gpio;
    }
    DC_WRITE(Adapter, Register, Data);
}

Referenced by DcInitialize(), MediaSelectMiiPort(), and MediaSiaSelect().

DcWriteSia()

VOID DcWriteSia	(	_In_ PDC21X4_ADAPTER	Adapter,
		_In_ ULONG	Csr13,
		_In_ ULONG	Csr14,
		_In_ ULONG	Csr15
	)

Definition at line 89 of file hardware.c.

{
    ULONG SiaConn, SiaGen;
 
    TRACE("CSR13 %08lx, CSR14 %08lx, CSR15 %08lx\n", Csr13, Csr14, Csr15);
 
    SiaConn = 0;
 
    /* The 21145 comes with 16 new bits in CSR13 */
    if (Adapter->Features & DC_SIA_ANALOG_CONTROL)
    {
        SiaConn = Adapter->AnalogControl;
    }
 
    /* Reset the transceiver */
    DC_WRITE(Adapter, DcCsr13_SiaConnectivity, SiaConn | DC_SIA_CONN_RESET);
    NdisStallExecution(20);
 
    /* Some chips don't have a separate GPIO register */
    if (Adapter->Features & DC_SIA_GPIO)
    {
        SiaGen = Adapter->SiaSetting;
        SiaGen &= 0xFFFF0000; /* GPIO */
        SiaGen |= Csr15;      /* SIA */
        Adapter->SiaSetting = SiaGen;
    }
    else
    {
        SiaGen = Csr15;
    }
 
    DC_WRITE(Adapter, DcCsr14_SiaTxRx, Csr14);
    DC_WRITE(Adapter, DcCsr15_SiaGeneral, SiaGen);
 
    /* Don't reset the transceiver twice */
    if (Csr13 == DC_SIA_CONN_RESET)
        return;
 
    DC_WRITE(Adapter, DcCsr13_SiaConnectivity, SiaConn | Csr13);
}

Referenced by DcSetupAdapter(), MediaMonitor21040Dpc(), MediaSelectMiiPort(), and MediaSiaSelect().

HpnaPhyInit()

VOID HpnaPhyInit

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 194 of file phy.c.

{
    ULONG SiaConn, i;
 
    PAGED_CODE();
 
    /* Select the HPNA interface */
    SiaConn = DC_READ(Adapter, DcCsr13_SiaConnectivity);
    SiaConn |= DC_SIA_CONN_HPNA;
    DC_WRITE(Adapter, DcCsr13_SiaConnectivity, SiaConn);
 
    for (i = 0; i < RTL_NUMBER_OF(Adapter->HpnaRegister); ++i)
    {
        if (Adapter->HpnaInitBitmap & (1 << i))
        {
            HpnaWrite(Adapter, i, Adapter->HpnaRegister[i]);
        }
    }
}

Referenced by DcSetupAdapter().

MediaGprSelect()

VOID MediaGprSelect

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 303 of file media.c.

{
    ULONG OpMode;
    PDC_MEDIA Media;
 
    INFO("Selected media %s\n", MediaNumber2Str(Adapter, Adapter->MediaNumber));
 
    Media = &Adapter->Media[Adapter->MediaNumber];
 
    DC_WRITE(Adapter, DcCsr12_Gpio, Media->GpioData);
 
    OpMode = Adapter->OpMode;
    OpMode &= ~DC_OPMODE_MEDIA_MASK;
    OpMode |= Media->OpMode;
    Adapter->OpMode = OpMode;
 
    DC_WRITE(Adapter, DcCsr6_OpMode, OpMode);
}

Referenced by DcSetupAdapter(), and MediaMonitor21140Dpc().

MediaIndicateConnect()

VOID MediaIndicateConnect	(	_In_ PDC21X4_ADAPTER	Adapter,
		_In_ BOOLEAN	LinkUp
	)

Definition at line 17 of file media.c.

{
    /* Nothing to do */
    if (Adapter->LinkUp == LinkUp)
        return;
 
    Adapter->LinkUp = LinkUp;
 
    INFO_VERB("Link %sconnected, media is %s\n",
              LinkUp ? "" : "dis",
              MediaNumber2Str(Adapter, Adapter->MediaNumber));
 
    NdisDprReleaseSpinLock(&Adapter->ModeLock);
 
    NdisMIndicateStatus(Adapter->AdapterHandle,
                        LinkUp ? NDIS_STATUS_MEDIA_CONNECT : NDIS_STATUS_MEDIA_DISCONNECT,
                        NULL,
                        0);
    NdisMIndicateStatusComplete(Adapter->AdapterHandle);
 
    NdisDprAcquireSpinLock(&Adapter->ModeLock);
}

Referenced by Media143Handle100LinkChange(), Media143Handle10LinkFail(), Media143Handle10LinkPass(), Media143SelectNextMedia(), MediaLinkStateChange21040(), MediaLinkStateChange21041(), MediaMonitor143(), MediaMonitor21040Dpc(), MediaMonitor21041Dpc(), MediaMonitor21140Dpc(), and MediaMonitor21143Dpc().

MediaInitDefaultMedia()

VOID MediaInitDefaultMedia	(	_In_ PDC21X4_ADAPTER	Adapter,
		_In_ ULONG	MediaNumber
	)

Definition at line 325 of file media.c.

{
    ULONG Csr14, MiiAdvertising, MiiControl, i;
    BOOLEAN UseMii;
 
    PAGED_CODE();
 
    /* Media auto-detection */
    if (MediaNumber == MEDIA_AUTO)
    {
        Adapter->Flags |= DC_AUTOSENSE;
 
        /* Initial value for all boards */
        Adapter->DefaultMedia = MEDIA_10T;
 
        Adapter->MiiAdvertising = Adapter->MiiMedia.Advertising;
        Adapter->MiiControl = MII_CR_AUTONEG | MII_CR_AUTONEG_RESTART;
 
        switch (Adapter->ChipType)
        {
            case DC21041:
            {
                /* Errata: don't enable auto-negotiation */
                if (Adapter->RevisionId < 0x20)
                    break;
 
                /* Advertise 10T HD and 10T FD. The chip chooses the 10T FD mode automatically */
                Adapter->Media[MEDIA_10T].Csr14 |= DC_SIA_TXRX_AUTONEG | DC_SIA_TXRX_ADV_10T_HD;
                Adapter->Media[MEDIA_10T].OpMode |= DC_OPMODE_FULL_DUPLEX;
                break;
            }
 
            case DC21140:
            {
                /* Pick the default media */
                if (Adapter->Features & DC_HAS_MII)
                {
                    Adapter->DefaultMedia = MEDIA_MII;
                    break;
                }
 
                /* The final entry in the media list should be checked first */
                _BitScanReverse(&Adapter->DefaultMedia, Adapter->MediaBitmap);
 
                /*
                 * Select the first half-duplex media.
                 * If you want to be able to use 21140 boards without MII in full-duplex mode,
                 * you have to manually select the media.
                 */
                for (i = Adapter->DefaultMedia; i > 0; --i)
                {
                    if ((Adapter->MediaBitmap & (1 << i)) && !MEDIA_IS_FD(i))
                        break;
                }
                Adapter->DefaultMedia = i;
                break;
            }
 
            case DC21143:
            case DC21145:
            {
                /* Pick the default media */
                if (Adapter->Features & DC_HAS_MII)
                {
                    Adapter->DefaultMedia = MEDIA_MII;
                }
                else if (Adapter->MediaBitmap & (1 << MEDIA_10T))
                {
                    /* Start at 10mbps to do internal auto-negotiation */
                    Adapter->DefaultMedia = MEDIA_10T;
                }
                else
                {
                    /* The final entry in the media list should be checked first */
                    _BitScanReverse(&Adapter->DefaultMedia, Adapter->MediaBitmap);
                }
 
                /* Enable the PCS function to do 100mbps parallel detection */
                if (Adapter->SymAdvertising & MII_ADV_100)
                {
                    Adapter->Media[MEDIA_10T].OpMode |= DC_OPMODE_PORT_PCS;
                    Adapter->Media[MEDIA_10T_FD].OpMode |= DC_OPMODE_PORT_PCS;
                    Adapter->Media[MEDIA_AUI].OpMode |= DC_OPMODE_PORT_PCS;
                    Adapter->Media[MEDIA_BNC].OpMode |= DC_OPMODE_PORT_PCS;
                    Adapter->Media[MEDIA_HMR].OpMode |= DC_OPMODE_PORT_PCS;
                }
 
                Csr14 = DC_SIA_TXRX_AUTONEG;
 
                if (Adapter->SymAdvertising & MII_ADV_10T_HD)
                    Csr14 |= DC_SIA_TXRX_ADV_10T_HD;
 
                /* When NWay is turned on, the FDX bit advertises 10T FD */
                if (Adapter->SymAdvertising & MII_ADV_10T_FD)
                    Adapter->Media[MEDIA_10T].OpMode |= DC_OPMODE_FULL_DUPLEX;
 
                if (Adapter->SymAdvertising & MII_ADV_100T_HD)
                    Csr14 |= DC_SIA_TXRX_ADV_100TX_HD;
 
                if (Adapter->SymAdvertising & MII_ADV_100T_FD)
                    Csr14 |= DC_SIA_TXRX_ADV_100TX_FD;
 
                if (Adapter->SymAdvertising & MII_ADV_100T4)
                    Csr14 |= DC_SIA_TXRX_ADV_100T4;
 
                /* Advertise the PHY capability */
                Adapter->Media[MEDIA_10T].Csr14 |= Csr14;
 
                /* This media may use GPIO data different from the 10T HD */
                Adapter->Media[MEDIA_10T_FD].Csr14 |= Csr14;
                break;
            }
 
            default:
                break;
        }
    }
    else /* Forced speed and duplex */
    {
        UseMii = FALSE;
 
        if (Adapter->Features & DC_HAS_MII)
        {
            if (!MEDIA_MII_OVERRIDE(MediaNumber))
            {
                UseMii = TRUE;
            }
        }
 
        if (!UseMii)
        {
            Adapter->DefaultMedia = MediaNumber;
 
            if (MEDIA_IS_10T(MediaNumber))
            {
                Adapter->InterruptMask &= ~DC_IRQ_LINK_CHANGED;
                Adapter->LinkStateChangeMask &= ~DC_IRQ_LINK_CHANGED;
            }
 
            if (MEDIA_IS_100(MediaNumber))
            {
                Adapter->InterruptMask &= ~(DC_IRQ_LINK_FAIL | DC_IRQ_LINK_PASS);
                Adapter->LinkStateChangeMask &= ~(DC_IRQ_LINK_FAIL | DC_IRQ_LINK_PASS);
            }
        }
        else
        {
            Adapter->DefaultMedia = MEDIA_MII;
 
            switch (MediaNumber)
            {
                case MEDIA_10T:
                    MiiAdvertising = MII_ADV_10T_HD;
                    break;
                case MEDIA_10T_FD:
                    MiiAdvertising = MII_ADV_10T_FD;
                    MiiControl = MII_CR_FULL_DUPLEX;
                    break;
                case MEDIA_100TX_HD:
                    MiiAdvertising = MII_ADV_100T_HD;
                    MiiControl = MII_CR_SPEED_SELECTION;
                    break;
                case MEDIA_100TX_FD:
                    MiiAdvertising = MII_ADV_100T_FD;
                    MiiControl = MII_CR_FULL_DUPLEX | MII_CR_SPEED_SELECTION;
                    break;
                case MEDIA_100T4:
                    MiiAdvertising = MII_ADV_100T4 | MII_CR_SPEED_SELECTION;
                    break;
 
                default:
                    MiiAdvertising = 0;
                    MiiControl = 0;
                    break;
            }
 
            if (MiiControl & MII_CR_SPEED_SELECTION)
                Adapter->LinkSpeedMbps = 100;
            else
                Adapter->LinkSpeedMbps = 10;
 
            Adapter->MiiAdvertising = MiiAdvertising;
            Adapter->MiiControl = MiiControl;
        }
    }
 
    INFO("Default media is %s\n", MediaNumber2Str(Adapter, Adapter->DefaultMedia));
}

Referenced by DcInitialize().

MediaInitMediaList()

VOID MediaInitMediaList

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 545 of file media.c.

{
    PAGED_CODE();
 
    /*
     * Set the default internal values for the SIA/SYM operating modes.
     * The SROM parsing code may later overwrite them.
     */
    switch (Adapter->ChipType)
    {
        case DC21040:
        {
            Adapter->Media[MEDIA_10T].Csr13 = 0x8F01;
            Adapter->Media[MEDIA_10T].Csr14 = 0xFFFF;
            Adapter->Media[MEDIA_10T].Csr15 = 0x0000;
 
            Adapter->Media[MEDIA_BNC].Csr13 = 0x8F09;
            Adapter->Media[MEDIA_BNC].Csr14 = 0x0705;
            Adapter->Media[MEDIA_BNC].Csr15 = 0x0006;
 
            Adapter->Media[MEDIA_10T_FD].Csr13 = 0x8F01;
            Adapter->Media[MEDIA_10T_FD].Csr14 = 0xFFFD;
            Adapter->Media[MEDIA_10T_FD].Csr15 = 0x0000;
            Adapter->Media[MEDIA_10T_FD].OpMode = DC_OPMODE_FULL_DUPLEX;
            break;
        }
 
        case DC21041:
        {
            Adapter->Media[MEDIA_10T].Csr13 = 0xEF01;
            Adapter->Media[MEDIA_10T].Csr14 = 0xFF3F;
            Adapter->Media[MEDIA_10T].Csr15 = 0x0008;
 
            Adapter->Media[MEDIA_BNC].Csr13 = 0xEF09;
            Adapter->Media[MEDIA_BNC].Csr14 = 0xF7FD;
            Adapter->Media[MEDIA_BNC].Csr15 = 0x0006;
 
            Adapter->Media[MEDIA_AUI].Csr13 = 0xEF09;
            Adapter->Media[MEDIA_AUI].Csr14 = 0xF7FD;
            Adapter->Media[MEDIA_AUI].Csr15 = 0x000E;
 
            Adapter->Media[MEDIA_10T_HD].Csr13 = 0xEF01;
            Adapter->Media[MEDIA_10T_HD].Csr14 = 0x7F3F;
            Adapter->Media[MEDIA_10T_HD].Csr15 = 0x0008;
 
            Adapter->Media[MEDIA_10T_FD].Csr13 = 0xEF01;
            Adapter->Media[MEDIA_10T_FD].Csr14 = 0x7F3D;
            Adapter->Media[MEDIA_10T_FD].Csr15 = 0x0008;
            Adapter->Media[MEDIA_10T_FD].OpMode = DC_OPMODE_FULL_DUPLEX;
            break;
        }
 
        case DC21140:
        {
            MediaInitOpMode2114x(Adapter);
            break;
        }
 
        case DC21143:
        case DC21145:
        {
            Adapter->Media[MEDIA_10T].Csr13 = 0x0001;
            Adapter->Media[MEDIA_10T].Csr14 = 0x7F3F;
            Adapter->Media[MEDIA_10T].Csr15 = 0x0008;
 
            Adapter->Media[MEDIA_BNC].Csr13 = 0x0009;
            Adapter->Media[MEDIA_BNC].Csr14 = 0x0705;
            Adapter->Media[MEDIA_BNC].Csr15 = 0x0006;
 
            Adapter->Media[MEDIA_AUI].Csr13 = 0x0009;
            Adapter->Media[MEDIA_AUI].Csr14 = 0x0705;
            Adapter->Media[MEDIA_AUI].Csr15 = 0x000E;
 
            Adapter->Media[MEDIA_10T_FD].Csr13 = 0x0001;
            Adapter->Media[MEDIA_10T_FD].Csr14 = 0x7F3D;
            Adapter->Media[MEDIA_10T_FD].Csr15 = 0x0008;
 
            Adapter->Media[MEDIA_HMR].Csr13 = 0x0009;
            Adapter->Media[MEDIA_HMR].Csr14 = 0x0505;
            Adapter->Media[MEDIA_HMR].Csr15 = 0x0010;
 
            MediaInitOpMode2114x(Adapter);
            break;
        }
 
        default:
            break;
    }
}

Referenced by DcInitialize().

MediaMiiCheckLink()

BOOLEAN MediaMiiCheckLink

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 141 of file media.c.

{
    ULONG MiiStatus;
    BOOLEAN FullDuplex, Speed100;
 
    /* The link status is a latched-low bit, read it twice */
    if (!MiiRead(Adapter, Adapter->PhyAddress, MII_STATUS, &MiiStatus))
    {
        goto NoLink;
    }
    if (!(MiiStatus & MII_SR_LINK_STATUS))
    {
        MiiRead(Adapter, Adapter->PhyAddress, MII_STATUS, &MiiStatus);
    }
    TRACE("MII Status %04lx\n", MiiStatus);
 
    /* Check the link status */
    if (!(MiiStatus & MII_SR_LINK_STATUS))
    {
NoLink:
        /* No link detected, check the other port */
        if (Adapter->MediaBitmap & ((1 << MEDIA_HMR) | (1 << MEDIA_AUI) | (1 << MEDIA_BNC)))
        {
            if ((Adapter->Features & DC_MII_AUTOSENSE) && !MEDIA_IS_FIXED(Adapter))
            {
                Adapter->MediaNumber = MediaMiiNextMedia(Adapter);
                MediaSiaSelect(Adapter);
            }
        }
 
        return FALSE;
    }
 
    /* If we are forcing speed and duplex */
    if (MEDIA_IS_FIXED(Adapter))
    {
        FullDuplex = !!(Adapter->MiiControl & MII_CR_FULL_DUPLEX);
        Speed100 = !!(Adapter->MiiControl & MII_CR_SPEED_SELECTION);
    }
    else
    {
        /* Check auto-negotiation is complete */
        if (!(MiiStatus & MII_SR_AUTONEG_COMPLETE))
            return FALSE;
 
        MediaMiiGetSpeedAndDuplex(Adapter, &FullDuplex, &Speed100);
    }
 
    /* Set the link speed and duplex */
    MediaMiiSetSpeedAndDuplex(Adapter, FullDuplex, Speed100);
 
    return TRUE;
}

Referenced by MediaMonitor21140Dpc(), and MediaMonitor21143Dpc().

MediaMiiSelect()

VOID MediaMiiSelect

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 197 of file media.c.

{
    ULONG MiiControl, MiiAdvertise;
 
    MiiRead(Adapter, Adapter->PhyAddress, MII_CONTROL, &MiiControl);
    MiiControl &= ~(MII_CR_POWER_DOWN | MII_CR_ISOLATE | MII_CR_RESET | MII_CR_SPEED_SELECTION |
                    MII_CR_FULL_DUPLEX | MII_CR_AUTONEG | MII_CR_AUTONEG_RESTART);
    MiiWrite(Adapter, Adapter->PhyAddress, MII_CONTROL, MiiControl);
 
    MiiControl |= Adapter->MiiControl;
    MiiAdvertise = Adapter->MiiAdvertising;
 
    MiiWrite(Adapter, Adapter->PhyAddress, MII_AUTONEG_ADVERTISE, MiiAdvertise | MII_ADV_CSMA);
    MiiWrite(Adapter, Adapter->PhyAddress, MII_CONTROL, MiiControl);
}

Referenced by DcSetupAdapter(), and Media143SelectNextSerialMedia().

MediaSelectMiiPort()

VOID MediaSelectMiiPort	(	_In_ PDC21X4_ADAPTER	Adapter,
		_In_ BOOLEAN	ResetPhy
	)

Definition at line 215 of file media.c.

{
    ULONG OpMode, i;
 
    if (Adapter->ChipType != DC21140)
    {
        DcWriteSia(Adapter, 0, 0, 0);
    }
 
    OpMode = Adapter->OpMode;
    OpMode &= ~DC_OPMODE_MEDIA_MASK;
    OpMode |= DC_OPMODE_PORT_SELECT | DC_OPMODE_PORT_HEARTBEAT_DISABLE;
    Adapter->OpMode = OpMode;
 
    DC_WRITE(Adapter, DcCsr6_OpMode, OpMode);
 
    NdisStallExecution(10);
 
    if (ResetPhy)
    {
        ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
 
        /* Execute the GPIO reset sequence */
        if (Adapter->MiiMedia.ResetStreamLength)
        {
            /* Set the GPIO direction */
            DcWriteGpio(Adapter, Adapter->MiiMedia.SetupStream[0]);
 
            for (i = 0; i < Adapter->MiiMedia.ResetStreamLength; ++i)
            {
                NdisMSleep(100);
                DcWriteGpio(Adapter, Adapter->MiiMedia.ResetStream[i]);
            }
 
            /* Give the PHY some time to reset */
            NdisMSleep(5000);
        }
    }
 
    /* Set the GPIO direction */
    DcWriteGpio(Adapter, Adapter->MiiMedia.SetupStream[0]);
 
    /* Execute the GPIO setup sequence */
    for (i = 1; i < Adapter->MiiMedia.SetupStreamLength; ++i)
    {
        NdisStallExecution(10);
        DcWriteGpio(Adapter, Adapter->MiiMedia.SetupStream[i]);
    }
}

Referenced by DcInitialize(), DcSetupAdapter(), and Media143SelectNextSerialMedia().

MediaSiaSelect()

VOID MediaSiaSelect

(

_In_ PDC21X4_ADAPTER

Adapter

)

Definition at line 268 of file media.c.

{
    ULONG OpMode;
    PDC_MEDIA Media;
 
    INFO_VERB("Selected media %s\n",
              MediaNumber2Str(Adapter, Adapter->MediaNumber));
 
    Media = &Adapter->Media[Adapter->MediaNumber];
 
    DcStopTxRxProcess(Adapter);
 
    if (Adapter->ChipType != DC21041)
    {
        /* Make sure the reset pulse is wide enough */
        NdisStallExecution(100);
        DcWriteGpio(Adapter, Media->GpioCtrl);
        NdisStallExecution(100);
        DcWriteGpio(Adapter, Media->GpioData);
    }
 
    DcWriteSia(Adapter, Media->Csr13, Media->Csr14, Media->Csr15);
 
    NdisStallExecution(10);
 
    OpMode = Adapter->OpMode;
    OpMode &= ~DC_OPMODE_MEDIA_MASK;
    OpMode |= Media->OpMode;
    Adapter->OpMode = OpMode;
 
    DC_WRITE(Adapter, DcCsr6_OpMode, OpMode);
}

Referenced by DcSetupAdapter(), Media041SelectNextMedia(), Media143Handle10LinkPass(), Media143HandleNWayComplete(), Media143SelectNextMedia(), Media143SelectNextSerialMedia(), MediaLinkStateChange21041(), MediaMiiCheckLink(), and MediaMonitor21041Dpc().

MiiRead()

BOOLEAN MiiRead	(	_In_ PDC21X4_ADAPTER	Adapter,
		_In_ ULONG	PhyAddress,
		_In_ ULONG	RegAddress,
		_Out_ PULONG	Data
	)

Definition at line 101 of file phy.c.

{
    ULONG Csr;
    BOOLEAN Success;
 
    MiiMdioPacket(Adapter, MDIO_PREAMBLE, 32);
    MiiMdioPacket(Adapter,
                  (MDIO_START << 12) |
                  (MDIO_READ  << 10) |
                  (PhyAddress << 5) |
                  RegAddress,
                  14);
 
    /* Turnaround */
    MiiMdioClearExtraBits(Adapter);
 
    Csr = DC_READ(Adapter, DcCsr9_SerialInterface);
    Success = !(Csr & DC_SERIAL_MII_MDI);
 
    *Data = MiiMdioShiftIn(Adapter);
 
    /* Idle state */
    MiiMdioClearExtraBits(Adapter);
 
    return Success;
}

Referenced by DcFindMiiPhy(), FindPhyDevice(), MediaMiiCheckLink(), MediaMiiGetSpeedAndDuplex(), MediaMiiSelect(), MiiGetSpeedAndDuplex(), NvNetInitNIC(), NvNetPhyInit(), NvNetSetSpeedAndDuplex(), PhyInit(), PhyInitCicadaSemiconductor(), PhyInitRealtek8201(), PhyInitRealtek8211c(), PhyInitVitesseSemiconductor(), and PhyReset().

MiiWrite()

BOOLEAN MiiWrite	(	_In_ PDC21X4_ADAPTER	Adapter,
		_In_ ULONG	PhyAddress,
		_In_ ULONG	RegAddress,
		_In_ ULONG	Data
	)

Definition at line 78 of file phy.c.

{
    MiiMdioPacket(Adapter, MDIO_PREAMBLE, 32);
    MiiMdioPacket(Adapter,
                  (MDIO_START << 30) |
                  (MDIO_WRITE << 28) |
                  (PhyAddress << 23) |
                  (RegAddress << 18) |
                  (MDIO_TA    << 16) |
                  Data,
                  32);
 
    /* Idle state */
    MiiMdioClearExtraBits(Adapter);
 
    return TRUE;
}

Referenced by MediaMiiSelect(), NvNetInitNIC(), PhyInit(), PhyInitCicadaSemiconductor(), PhyInitRealtek8201(), PhyInitRealtek8211b(), PhyInitRealtek8211c(), PhyInitVitesseSemiconductor(), and PhyReset().

Variable Documentation

DriverEntry

DRIVER_INITIALIZE DriverEntry

Definition at line 276 of file dc21x4.h.

MediaLinkStateChange21040

MEDIA_HANDLE_LINK_STATE_CHANGE MediaLinkStateChange21040

Definition at line 502 of file dc21x4.h.

Referenced by DcRecognizeHardware().

MediaLinkStateChange21041

MEDIA_HANDLE_LINK_STATE_CHANGE MediaLinkStateChange21041

Definition at line 503 of file dc21x4.h.

Referenced by DcRecognizeHardware().

MediaLinkStateChange21143

MEDIA_HANDLE_LINK_STATE_CHANGE MediaLinkStateChange21143

Definition at line 504 of file dc21x4.h.

Referenced by DcRecognizeHardware().

MediaMonitor21040Dpc

NDIS_TIMER_FUNCTION MediaMonitor21040Dpc

Definition at line 497 of file dc21x4.h.

Referenced by DcRecognizeHardware().

MediaMonitor21041Dpc

NDIS_TIMER_FUNCTION MediaMonitor21041Dpc

Definition at line 498 of file dc21x4.h.

Referenced by DcRecognizeHardware().

MediaMonitor21140Dpc

NDIS_TIMER_FUNCTION MediaMonitor21140Dpc

Definition at line 499 of file dc21x4.h.

Referenced by DcRecognizeHardware().

MediaMonitor21143Dpc

NDIS_TIMER_FUNCTION MediaMonitor21143Dpc

Definition at line 500 of file dc21x4.h.

Referenced by DcRecognizeHardware().

SRompAdapterList

LIST_ENTRY SRompAdapterList

extern

Definition at line 30 of file eeprom.c.

Referenced by DriverEntry(), SRomIsAdapterInList(), and SRomRegisterMasterAdapter().