diff options
Diffstat (limited to '')
-rw-r--r-- | private/ntos/ndis/wd/wdsft.h | 852 |
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 |