1 files changed, 852 insertions, 0 deletions

diff --git a/private/ntos/ndis/wd/wdsft.h b/private/ntos/ndis/wd/wdsft.h
new file mode 100644
index 000000000..3ea3f8d17
--- /dev/null
+++ b/private/ntos/ndis/wd/wdsft.h
@@ -0,0 +1,852 @@
+/*++
+
+Copyright (c) 1990  Microsoft Corporation
+
+Module Name:
+
+    wdsft.h
+
+Abstract:
+
+    The main header for an Western Digital MAC driver.
+
+Author:
+
+    Anthony V. Ercolano (tonye) creation-date 19-Jun-1990 (Driver Model)
+
+    Sean Selitrennikoff (seanse) original WD code.
+
+Environment:
+
+    This driver is expected to work in DOS, OS2 and NT at the equivalent
+    of kernal mode.
+
+    Architecturally, there is an assumption in this driver that we are
+    on a little endian machine.
+
+Notes:
+
+    optional-notes
+
+Revision History:
+
+
+--*/
+
+#ifndef _WDSFT_
+#define _WDSFT_
+
+#define WD_NDIS_MAJOR_VERSION 3
+#define WD_NDIS_MINOR_VERSION 0
+
+//
+// This macro is used along with the flags to selectively
+// turn on debugging.
+//
+
+#if DBG
+
+#define IF_WDDEBUG(f) if (WdDebugFlag & (f))
+
+extern ULONG WdDebugFlag;
+
+#define WD_DEBUG_LOUD               0x00000001  // debugging info
+#define WD_DEBUG_VERY_LOUD          0x00000002  // excessive debugging info
+#define WD_DEBUG_LOG                0x00000004  // enable WdLog
+#define WD_DEBUG_CHECK_DUP_SENDS    0x00000008  // check for duplicate sends
+#define WD_DEBUG_TRACK_PACKET_LENS  0x00000010  // track directed packet lens
+#define WD_DEBUG_WORKAROUND1        0x00000020  // drop DFR/DIS packets
+#define WD_DEBUG_CARD_BAD           0x00000040  // dump data if CARD_BAD
+#define WD_DEBUG_CARD_TESTS         0x00000080  // print reason for failing
+
+
+
+//
+// Macro for deciding whether to dump lots of debugging information.
+//
+
+#define IF_LOUD(A) IF_WDDEBUG( WD_DEBUG_LOUD ) { A }
+#define IF_VERY_LOUD(A) IF_WDDEBUG( WD_DEBUG_VERY_LOUD ) { A }
+
+#else
+
+#define IF_LOUD(A)
+#define IF_VERY_LOUD(A)
+
+#endif
+
+
+//
+// Macros for services that differ between DOS and NT, we may consider adding these
+// into the NDIS spec.
+//
+
+
+//
+// controls the number of transmit buffers on the packet.
+// Choices are 1 or 2.
+//
+
+#define DEFAULT_NUMBUFFERS 2
+
+
+//
+// Macros for moving memory around
+//
+
+#define WD_MOVE_MEM(dest,src,size) NdisMoveMemory(dest,src,size)
+#define WD_MOVE_MEM_TO_SHARED_RAM(dest,src,size) NdisMoveToMappedMemory(dest,src,size)
+#define WD_MOVE_SHARED_RAM_TO_MEM(dest,src,size) NdisMoveFromMappedMemory(dest,src,size)
+
+#define WD_MOVE_DWORD_TO_SHARED_RAM(dest,src) NdisWriteRegisterUlong((PULONG)(dest),(ULONG)(src))
+#define WD_MOVE_SHARED_RAM_TO_DWORD(dest,src) NdisReadRegisterUlong((PULONG)(src),(PULONG)(dest))
+
+#define WD_MOVE_UCHAR_TO_SHARED_RAM(dest,src) NdisWriteRegisterUchar((PUCHAR)(dest),(UCHAR)(src))
+#define WD_MOVE_SHARED_RAM_TO_UCHAR(dest,src) NdisReadRegisterUchar((PUCHAR)(src),(PUCHAR)(dest))
+
+#define WD_MOVE_USHORT_TO_SHARED_RAM(dest,src) NdisWriteRegisterUshort((PUSHORT)(dest),(USHORT)(src))
+#define WD_MOVE_SHARED_RAM_TO_USHORT(dest,src) NdisReadRegisterUshort((PUSHORT)(src),(PUSHORT)(dest))
+
+
+
+
+//
+// A broadcast address (for comparing with other addresses).
+//
+
+extern UCHAR WdBroadcastAddress[];
+
+
+//
+// Number of bytes in an ethernet header
+//
+
+#define WD_HEADER_SIZE 14
+
+
+//
+// Number of bytes allowed in a lookahead (max)
+//
+
+#define WD_MAX_LOOKAHEAD (252 - WD_HEADER_SIZE)
+
+
+//
+// Buffer page size - WD MUST BE 256!!!  Internal counters on the card
+// depend on it.
+//
+
+#define WD_BUFFER_PAGE_SIZE 256
+
+
+//
+// Only have one of these structures.
+//
+
+typedef struct _MAC_BLOCK {
+
+    //
+    // NDIS wrapper information.
+    //
+
+    NDIS_HANDLE NdisMacHandle;          // returned from NdisRegisterMac
+    NDIS_HANDLE NdisWrapperHandle;      // returned from NdisInitializeWrapper
+    NDIS_MAC_CHARACTERISTICS MacCharacteristics;
+
+    //
+    // Adapters registered for this MAC.
+    //
+
+    UINT NumAdapters;
+    struct _WD_ADAPTER * AdapterQueue;
+    NDIS_SPIN_LOCK SpinLock;            // guards NumAdapter and AdapterQueue
+
+    //
+    // driver object.
+    //
+
+    PDRIVER_OBJECT DriverObject;
+
+    BOOLEAN Unloading;
+
+} MAC_BLOCK, * PMAC_BLOCK;
+
+
+
+
+
+
+//
+// One of these structures per adapter registered.
+//
+
+typedef struct _WD_ADAPTER {
+
+    //
+    // Adapter structure for LMI.
+    // This must occur first in the adapter structure.
+    //
+
+    Adapter_Struc LMAdapter;
+
+    //
+    // Spin lock for adapter structure
+    //
+    NDIS_SPIN_LOCK Lock;
+
+
+    //
+    // Links with our MAC.
+    //
+
+    PMAC_BLOCK MacBlock;
+    struct _WD_ADAPTER * NextAdapter;    // used by MacBlock->OpenQueue
+
+    //
+    // Opens for this adapter.
+    //
+
+    struct _WD_OPEN * OpenQueue;
+
+
+    //
+    // Number of references to the adapter.
+    //
+    ULONG References;
+
+    UINT MulticastListMax;
+
+    //
+    // Transmit queue.
+    //
+
+    PNDIS_PACKET XmitQueue;             // packets waiting to be transmitted
+    PNDIS_PACKET XmitQTail;
+
+    PNDIS_PACKET PacketsOnCard;         // List of packets that the card is
+                                        // is currently transmitting
+    PNDIS_PACKET PacketsOnCardTail;
+
+    //
+    // Loopback queue;
+    //
+
+    PNDIS_PACKET LoopbackQueue;         // directed packets waiting to be received
+    PNDIS_PACKET LoopbackQTail;
+    PNDIS_PACKET IndicatingPacket;
+    BOOLEAN IndicatedAPacket;
+
+    //
+    // These are for the current packet being indicated.
+    //
+
+    UCHAR PacketHeader[4];              // the NIC appended header
+    UINT PacketLen;                     // the overall length of the packet
+
+
+
+    //
+    // Statistics used by Set/QueryInformation.
+    //
+
+    ULONG FramesXmitGood;               // Good Frames Transmitted
+    ULONG FramesRcvGood;                // Good Frames Received
+
+    ULONG FramesXmitBad;                // Bad Frames Transmitted
+    ULONG FramesXmitOneCollision;       // Frames Transmitted with one collision
+    ULONG FramesXmitManyCollisions;     // Frames Transmitted with > 1 collision
+    ULONG FramesXmitDeferred;           // Frames where xmit was deferred
+    ULONG FramesXmitOverWrite;          // Frames where xmit was overwritten
+    ULONG FramesXmitHeartbeat;          // Frames lost heartbeat
+    ULONG FramesXmitUnderruns;          // Frames where FIFO underran
+
+    ULONG FrameAlignmentErrors;         // FAE errors counted
+    ULONG CrcErrors;                    // CRC errors counted
+    ULONG MissedPackets;                // missed packet counted
+    ULONG TooBig;                       // received packets too large counted
+    ULONG Overruns;                     // received packets with FIFO overrun
+
+    //
+    // Reset information.
+    //
+
+    BOOLEAN HardwareFailure;            // Did the hardware fail in some way
+    BOOLEAN ResetRequested;             // TRUE if a reset is needed
+    BOOLEAN ResetInProgress;            // TRUE if a reset is in progress
+    struct _WD_OPEN * ResetOpen;        // who called WdReset
+
+    UINT ByteToWrite;                   // temp storage
+
+
+    //
+    // Look Ahead information.
+    //
+
+    ULONG MaxLookAhead;
+
+
+    //
+    // Handling deferred events
+    //
+
+    NDIS_TIMER DeferredTimer;
+    PVOID DeferredDpc;
+
+    UCHAR LookAhead[WD_MAX_LOOKAHEAD + WD_HEADER_SIZE];
+
+    BOOLEAN Removed;
+
+    //
+    // For handling missing interrupts (caused by user mis-configs)
+    //
+
+    PVOID WakeUpDpc;
+    NDIS_TIMER WakeUpTimer;
+    BOOLEAN WakeUpTimeout;
+    UCHAR WakeUpErrorCount;
+
+    BOOLEAN         ProcessingDpc;
+} WD_ADAPTER, * PWD_ADAPTER;
+
+
+
+
+//
+// Given a MacBindingHandle this macro returns a pointer to the
+// WD_ADAPTER.
+//
+#define PWD_ADAPTER_FROM_BINDING_HANDLE(Handle) \
+    (((PWD_OPEN)(Handle))->Adapter)
+
+//
+// Given a MacContextHandle return the PWD_ADAPTER
+// it represents.
+//
+#define PWD_ADAPTER_FROM_CONTEXT_HANDLE(Handle) \
+    ((PWD_ADAPTER)(Handle))
+
+//
+// Given a pointer to a WD_ADAPTER return the
+// proper MacContextHandle.
+//
+#define CONTEXT_HANDLE_FROM_PWD_ADAPTER(Ptr) \
+    ((NDIS_HANDLE)(Ptr))
+
+
+//
+// Given a pointer to a WD_ADAPTER, return the
+// pointer to the LMAdapter.
+//
+#define Ptr_Adapter_Struc_FROM_PWD_ADAPTER(P)\
+    (&((P)->LMAdapter))
+
+//
+// Given a pointer to a LMAdapter, return the
+// pointer to the WD_ADAPTER.
+//
+#define PWD_ADAPTER_FROM_Ptr_Adapter_Struc(P)\
+    ((PWD_ADAPTER)(P))
+
+
+
+
+//
+// Macros to extract high and low bytes of a word.
+//
+
+#define MSB(Value) ((UCHAR)(((Value) >> 8) & 0xff))
+#define LSB(Value) ((UCHAR)((Value) & 0xff))
+
+
+//
+// One of these per open on an adapter.
+//
+
+typedef struct _WD_OPEN {
+
+    //
+    // NDIS wrapper information.
+    //
+
+    NDIS_HANDLE NdisBindingContext;     // passed to MacOpenAdapter
+    PSTRING AddressingInformation;      // not used currently
+
+    //
+    // Links to our adapter.
+    //
+
+    PWD_ADAPTER Adapter;
+    struct _WD_OPEN * NextOpen;
+
+    //
+    // Links to our MAC.
+    //
+
+    PMAC_BLOCK MacBlock;            // faster than using AdapterBlock->MacBlock
+
+
+    //
+    // Handle of this adapter in the filter database.
+    //
+    NDIS_HANDLE NdisFilterHandle;
+
+    //
+    // Indication information
+    //
+
+    UINT LookAhead;
+
+    //
+    // Reset/Close information.
+    //
+
+    UINT ReferenceCount;             // number of reasons this open can't close
+    BOOLEAN Closing;                 // is a close pending
+
+    NDIS_REQUEST CloseFilterRequest; // Holds Requests for pending close op
+    NDIS_REQUEST CloseAddressRequest;// Holds Requests for pending close op
+
+    UINT ProtOptionFlags;
+
+} WD_OPEN, * PWD_OPEN;
+
+
+//
+// This macro returns a pointer to a PWD_OPEN given a MacBindingHandle.
+//
+#define PWD_OPEN_FROM_BINDING_HANDLE(Handle) \
+    ((PWD_OPEN)(Handle))
+
+//
+// This macro returns a NDIS_HANDLE from a PWD_OPEN
+//
+#define BINDING_HANDLE_FROM_PWD_OPEN(Open) \
+    ((NDIS_HANDLE)(Open))
+
+
+
+
+
+//
+// What we map into the reserved section of a packet.
+// Cannot be more than 16 bytes (see ASSERT in wd.c).
+//
+
+typedef struct _MAC_RESERVED {
+    PNDIS_PACKET NextPacket;    // used to link in the queues (4 bytes)
+    PWD_OPEN Open;              // open that called WdSend (4 bytes)
+    BOOLEAN Loopback;           // is this a loopback packet (1 byte)
+    BOOLEAN Directed;           // is this a directed packet (1 byte)
+} MAC_RESERVED, * PMAC_RESERVED;
+
+
+//
+// These appear in the status field of MAC_RESERVED; they are
+// used because there is not enough room for a full NDIS_HANDLE.
+//
+
+#define RESERVED_SUCCESS   ((USHORT)0)
+#define RESERVED_FAILURE   ((USHORT)1)
+
+
+//
+// Retrieve the MAC_RESERVED structure from a packet.
+//
+
+#define RESERVED(Packet) ((PMAC_RESERVED)((Packet)->MacReserved))
+
+
+//
+// Procedures which log errors.
+//
+
+typedef enum _WD_PROC_ID {
+    openAdapter,
+    cardReset,
+    cardCopyDownPacket,
+    cardCopyDownBuffer,
+    cardCopyUp
+} WD_PROC_ID;
+
+
+#define WD_ERRMSG_CARD_SETUP          (ULONG)0x01
+#define WD_ERRMSG_DATA_PORT_READY     (ULONG)0x02
+#define WD_ERRMSG_MAX_OPENS           (ULONG)0x03
+
+
+
+
+
+//
+// This macro will act a "epilogue" to every routine in the
+// *interface*.  It will check whether any requests need
+// to defer their processing.  It will also decrement the reference
+// count on the adapter.  If the reference count is zero and there
+// is deferred work to do it will insert the interrupt processing
+// routine in the DPC queue.
+//
+// Note that we don't need to include checking for blocked receives
+// since blocked receives imply that there will eventually be an
+// interrupt.
+//
+// NOTE: This macro assumes that it is called with the lock acquired.
+//
+//
+#define WD_DO_DEFERRED(Adapter) \
+{ \
+    PWD_ADAPTER _A = (Adapter); \
+    _A->References--; \
+    if ((!_A->References) && \
+        ((_A->ResetRequested && (!_A->ProcessingDpc)) || \
+         ((_A->LoopbackQueue != NULL) && (!_A->ProcessingDpc)))) \
+    {\
+        NdisReleaseSpinLock(&_A->Lock); \
+        NdisSetTimer(&_A->DeferredTimer, 0);\
+    } else { \
+        NdisReleaseSpinLock(&_A->Lock); \
+    } \
+}
+
+
+
+
+//
+// Declarations for functions in wd.c.
+//
+
+NDIS_STATUS
+WdRegisterAdapter(
+    IN PWD_ADAPTER Adapter,
+    IN UINT NumBuffers,
+    IN UINT MulticastListMax,
+    IN UCHAR NodeAddress[ETH_LENGTH_OF_ADDRESS]
+    );
+
+
+BOOLEAN
+WdInterruptHandler(
+    IN PVOID ServiceContext         // will be a pointer to the adapter block
+    );
+
+VOID
+WdInterruptDpc(
+    IN PVOID SystemSpecific1,
+    IN PVOID InterruptContext,
+    IN PVOID SystemSpecific2,
+    IN PVOID SystemSpecific3
+    );
+
+NDIS_STATUS
+WdOpenAdapter(
+    OUT PNDIS_STATUS OpenErrorStatus,
+    OUT NDIS_HANDLE * MacBindingHandle,
+    OUT PUINT SelectedMediumIndex,
+    IN PNDIS_MEDIUM MediumArray,
+    IN UINT MediumArraySize,
+    IN NDIS_HANDLE NdisBindingContext,
+    IN NDIS_HANDLE MacAdapterContext,
+    IN UINT OpenOptions,
+    IN PSTRING AddressingInformation OPTIONAL
+    );
+
+
+NDIS_STATUS
+WdCloseAdapter(
+    IN NDIS_HANDLE MacBindingHandle
+    );
+
+
+BOOLEAN
+WdAddReference(
+    IN PWD_OPEN OpenP
+    );
+
+
+#define WdRemoveReference(_Open) \
+{                                                           \
+    PWD_ADAPTER _Adapter = _Open->Adapter;                  \
+    PWD_OPEN _TmpOpen = _Open;                              \
+    --_TmpOpen->ReferenceCount;                             \
+    if (_TmpOpen->ReferenceCount == 0) {                    \
+        if (_TmpOpen == _Adapter->OpenQueue) {              \
+            _Adapter->OpenQueue = _TmpOpen->NextOpen;       \
+        } else {                                            \
+            _TmpOpen = _Adapter->OpenQueue;                 \
+            while (_TmpOpen->NextOpen != _Open) {           \
+                _TmpOpen = _TmpOpen->NextOpen;              \
+            }                                               \
+            _TmpOpen->NextOpen = _Open->NextOpen;           \
+            _TmpOpen = _Open;                               \
+        }                                                   \
+        if (_TmpOpen->LookAhead == _Adapter->MaxLookAhead) {\
+            WdAdjustMaxLookAhead(_Adapter);                 \
+        }                                                   \
+        NdisReleaseSpinLock(&_Adapter->Lock);               \
+        NdisCompleteCloseAdapter (_TmpOpen->NdisBindingContext, NDIS_STATUS_SUCCESS); \
+        NdisFreeMemory(_TmpOpen, sizeof(WD_OPEN), 0);       \
+        NdisAcquireSpinLock(&_Adapter->Lock);               \
+        if (_Adapter->OpenQueue == NULL) {                  \
+            NdisSynchronizeWithInterrupt(                   \
+                  &(_Adapter->LMAdapter.NdisInterrupt),     \
+                  (PVOID)WdSyncCloseAdapter,                \
+                  (PVOID)(&(_Adapter->LMAdapter))           \
+                 );                                         \
+        }                                                   \
+    }                                                       \
+}
+
+VOID
+WdAdjustMaxLookAhead(
+    IN PWD_ADAPTER Adapter
+    );
+
+NDIS_STATUS
+WdReset(
+    IN NDIS_HANDLE MacBindingHandle
+    );
+
+NDIS_STATUS
+WdRequest(
+    IN NDIS_HANDLE MacBindingHandle,
+    IN PNDIS_REQUEST NdisRequest
+    );
+
+NDIS_STATUS
+WdQueryInformation(
+    IN PWD_ADAPTER Adapter,
+    IN PWD_OPEN Open,
+    IN PNDIS_REQUEST NdisRequest
+    );
+
+NDIS_STATUS
+WdSetInformation(
+    IN PWD_ADAPTER Adapter,
+    IN PWD_OPEN Open,
+    IN PNDIS_REQUEST NdisRequest
+    );
+
+NDIS_STATUS
+WdSetMulticastAddresses(
+    IN PWD_ADAPTER Adapter,
+    IN PWD_OPEN Open,
+    IN PNDIS_REQUEST NdisRequest,
+    IN UINT NumAddresses,
+    IN CHAR AddressList[][ETH_LENGTH_OF_ADDRESS]
+    );
+
+NDIS_STATUS
+WdSetPacketFilter(
+    IN PWD_ADAPTER Adapter,
+    IN PWD_OPEN Open,
+    IN PNDIS_REQUEST NdisRequest,
+    IN UINT PacketFilter
+    );
+
+NDIS_STATUS
+WdQueryGlobalStatistics(
+    IN NDIS_HANDLE MacBindingHandle,
+    IN PNDIS_REQUEST NdisRequest
+    );
+
+VOID
+WdUnload(
+    IN NDIS_HANDLE MacMacContext
+    );
+
+NDIS_STATUS
+WdAddAdapter(
+    IN NDIS_HANDLE NdisMacContext,
+    IN NDIS_HANDLE ConfigurationHandle,
+    IN PNDIS_STRING AdaptName
+    );
+
+VOID
+WdRemoveAdapter(
+    IN PVOID MacAdapterContext
+    );
+
+VOID
+WdInterruptDpc(
+    IN PVOID SystemSpecific1,
+    IN PVOID InterruptContext,
+    IN PVOID SystemSpecific2,
+    IN PVOID SystemSpecific3
+    );
+
+NDIS_STATUS
+WdChangeMulticastAddresses(
+    IN UINT OldFilterCount,
+    IN CHAR OldAddresses[][ETH_LENGTH_OF_ADDRESS],
+    IN UINT NewFilterCount,
+    IN CHAR NewAddresses[][ETH_LENGTH_OF_ADDRESS],
+    IN NDIS_HANDLE MacBindingHandle,
+    IN PNDIS_REQUEST NdisRequest,
+    IN BOOLEAN Set
+    );
+
+NDIS_STATUS
+WdChangeFilterClasses(
+    IN UINT OldFilterClasses,
+    IN UINT NewFilterClasses,
+    IN NDIS_HANDLE MacBindingHandle,
+    IN PNDIS_REQUEST NdisRequest,
+    IN BOOLEAN Set
+    );
+
+
+VOID
+WdCloseAction(
+    IN NDIS_HANDLE MacBindingHandle
+    );
+
+
+UINT
+WdPacketSize(
+    IN PNDIS_PACKET Packet
+    );
+
+
+INDICATE_STATUS
+WdIndicatePacket(
+    IN PWD_ADAPTER Adapter
+    );
+
+
+NDIS_STATUS
+WdTransferData(
+    IN NDIS_HANDLE MacBindingHandle,
+    IN NDIS_HANDLE MacReceiveContext,
+    IN UINT ByteOffset,
+    IN UINT BytesToTransfer,
+    OUT PNDIS_PACKET Packet,
+    OUT PUINT BytesTransferred
+    );
+
+
+BOOLEAN
+WdReceiveEvents(
+    IN PWD_ADAPTER Adapter
+    );
+
+BOOLEAN
+WdReceiveEventsDpc(
+    IN PVOID SystemSpecific1,
+    IN PVOID Context,
+    IN PVOID SystemSpecific2,
+    IN PVOID SystemSpecific3
+    );
+
+VOID
+WdTransmitEvents(
+    IN PWD_ADAPTER Adapter
+    );
+
+NDIS_STATUS
+WdSend(
+    IN NDIS_HANDLE MacBindingHandle,
+    IN PNDIS_PACKET Packet
+    );
+
+UINT
+WdCompareMemory(
+    IN PUCHAR String1,
+    IN PUCHAR String2,
+    IN UINT Length
+    );
+
+VOID
+WdSetLoopbackFlag(
+    IN PWD_ADAPTER Adapter,
+    IN PWD_OPEN Open,
+    IN OUT PNDIS_PACKET Packet
+    );
+
+VOID
+WdIndicateLoopbackPacket(
+    IN PWD_ADAPTER Adapter,
+    IN PNDIS_PACKET Packet
+    );
+
+BOOLEAN
+WdSyncCloseAdapter(
+    IN PVOID Context
+    );
+
+BOOLEAN
+WdSyncSend(
+    IN PVOID Context
+    );
+
+BOOLEAN
+WdSyncSetMulticastAddress(
+    IN PVOID Context
+    );
+
+VOID
+WdWakeUpDpc(
+    IN PVOID SystemSpecific1,
+    IN PVOID Context,
+    IN PVOID SystemSpecific2,
+    IN PVOID SystemSpecific3
+    );
+
+//++
+//
+// VOID
+// AddRefWhileHoldingSpinLock(
+//     IN PWD_ADAPTER Adapter,
+//     IN PWD_OPEN OpenP
+//     )
+//
+// Routine Description:
+//
+//  Adds a reference to an open. Similar to AddReference, but
+//  called with Adapter->Lock held.
+//
+// Arguments:
+//
+//  Adapter - The adapter block of OpenP.
+//  OpenP - The open block that is being referenced.
+//
+// Return Value:
+//
+//  None.
+//
+//--
+
+#define AddRefWhileHoldingSpinLock(Adapter, OpenP) { \
+    ++((OpenP)->ReferenceCount); \
+}
+
+
+
+//++
+//
+// BOOLEAN
+// WdAddressEqual(
+//     IN UCHAR Address1[ETH_LENGTH_OF_ADDRESS],
+//     IN UCHAR Address2[ETH_LENGTH_OF_ADDRESS]
+//     )
+//
+// Routine Description:
+//
+//  Compares two Ethernet addresses.
+//
+// Arguments:
+//
+//  Address1 - The first address.
+//  Address2 - The second address.
+//
+// Return Value:
+//
+//  TRUE if the addresses are equal.
+//  FALSE if they are not.
+//
+//--
+
+#define WdAddressEqual(Address1, Address2) \
+    ((Address1)[4] == (Address2)[4] && \
+        WdCompareMemory((Address1), (Address2), ETH_LENGTH_OF_ADDRESS) == 0)
+
+
+#endif // WdSFT