diff options
Diffstat (limited to 'private/ntos/ndis/ndis30/ndismini.h')
| -rw-r--r-- | private/ntos/ndis/ndis30/ndismini.h | 1216 |
1 files changed, 1216 insertions, 0 deletions
diff --git a/private/ntos/ndis/ndis30/ndismini.h b/private/ntos/ndis/ndis30/ndismini.h new file mode 100644 index 000000000..38892897d --- /dev/null +++ b/private/ntos/ndis/ndis30/ndismini.h @@ -0,0 +1,1216 @@ +#include <afilter.h> +#include <efilter.h> +#include <tfilter.h> +#include <ffilter.h> + +#define NDIS_M_MAX_MULTI_LIST 32 +#define NDIS_M_MAX_LOOKAHEAD 526 + +// +// declare these first since they point to each other +// + +typedef struct _NDIS_M_DRIVER_BLOCK NDIS_M_DRIVER_BLOCK, * PNDIS_M_DRIVER_BLOCK; +typedef struct _NDIS_MINIPORT_BLOCK NDIS_MINIPORT_BLOCK, * PNDIS_MINIPORT_BLOCK; +typedef struct _NDIS_M_PROTOCOL_BLOCK NDIS_M_PROTOCOL_BLOCK, * PNDIS_M_PROTOCOL_BLOCK; +typedef struct _NDIS_M_OPEN_BLOCK NDIS_M_OPEN_BLOCK, * PNDIS_M_OPEN_BLOCK; + + +// +// Function types for NDIS_MINIPORT_CHARACTERISTICS +// + + +typedef +BOOLEAN +(*W_CHECK_FOR_HANG_HANDLER) ( + IN NDIS_HANDLE MiniportAdapterContext + ); + +typedef +VOID +(*W_DISABLE_INTERRUPT_HANDLER) ( + IN NDIS_HANDLE MiniportAdapterContext + ); + +typedef +VOID +(*W_ENABLE_INTERRUPT_HANDLER) ( + IN NDIS_HANDLE MiniportAdapterContext + ); + +typedef +VOID +(*W_HALT_HANDLER) ( + IN NDIS_HANDLE MiniportAdapterContext + ); + +typedef +VOID +(*W_HANDLE_INTERRUPT_HANDLER) ( + IN NDIS_HANDLE MiniportAdapterContext + ); + +typedef +NDIS_STATUS +(*W_INITIALIZE_HANDLER) ( + OUT PNDIS_STATUS OpenErrorStatus, + OUT PUINT SelectedMediumIndex, + IN PNDIS_MEDIUM MediumArray, + IN UINT MediumArraySize, + IN NDIS_HANDLE MiniportAdapterHandle, + IN NDIS_HANDLE WrapperConfigurationContext + ); + +typedef +VOID +(*W_ISR_HANDLER) ( + OUT PBOOLEAN InterruptRecognized, + OUT PBOOLEAN QueueMiniportHandleInterrupt, + IN NDIS_HANDLE MiniportAdapterContext + ); + +typedef +NDIS_STATUS +(*W_QUERY_INFORMATION_HANDLER) ( + IN NDIS_HANDLE MiniportAdapterContext, + IN NDIS_OID Oid, + IN PVOID InformationBuffer, + IN ULONG InformationBufferLength, + OUT PULONG BytesWritten, + OUT PULONG BytesNeeded + ); + +typedef +NDIS_STATUS +(*W_RECONFIGURE_HANDLER) ( + OUT PNDIS_STATUS OpenErrorStatus, + IN NDIS_HANDLE MiniportAdapterContext, + IN NDIS_HANDLE WrapperConfigurationContext + ); + +typedef +NDIS_STATUS +(*W_RESET_HANDLER) ( + OUT PBOOLEAN AddressingReset, + IN NDIS_HANDLE MiniportAdapterContext + ); + +typedef +NDIS_STATUS +(*W_SEND_HANDLER) ( + IN NDIS_HANDLE MiniportAdapterContext, + IN PNDIS_PACKET Packet, + IN UINT Flags + ); + +typedef +NDIS_STATUS +(*W_SET_INFORMATION_HANDLER) ( + IN NDIS_HANDLE MiniportAdapterContext, + IN NDIS_OID Oid, + IN PVOID InformationBuffer, + IN ULONG InformationBufferLength, + OUT PULONG BytesRead, + OUT PULONG BytesNeeded + ); + +typedef +NDIS_STATUS +(*W_TRANSFER_DATA_HANDLER) ( + OUT PNDIS_PACKET Packet, + OUT PUINT BytesTransferred, + IN NDIS_HANDLE MiniportAdapterContext, + IN NDIS_HANDLE MiniportReceiveContext, + IN UINT ByteOffset, + IN UINT BytesToTransfer + ); + +typedef struct _NDIS_MINIPORT_CHARACTERISTICS { + UCHAR MajorNdisVersion; + UCHAR MinorNdisVersion; + UINT Reserved; + W_CHECK_FOR_HANG_HANDLER CheckForHangHandler; + W_DISABLE_INTERRUPT_HANDLER DisableInterruptHandler; + W_ENABLE_INTERRUPT_HANDLER EnableInterruptHandler; + W_HALT_HANDLER HaltHandler; + W_HANDLE_INTERRUPT_HANDLER HandleInterruptHandler; + W_INITIALIZE_HANDLER InitializeHandler; + W_ISR_HANDLER ISRHandler; + W_QUERY_INFORMATION_HANDLER QueryInformationHandler; + W_RECONFIGURE_HANDLER ReconfigureHandler; + W_RESET_HANDLER ResetHandler; + W_SEND_HANDLER SendHandler; + W_SET_INFORMATION_HANDLER SetInformationHandler; + W_TRANSFER_DATA_HANDLER TransferDataHandler; +} NDIS_MINIPORT_CHARACTERISTICS, *PNDIS_MINIPORT_CHARACTERISTICS; + +// +// one of these per Driver +// + +struct _NDIS_M_DRIVER_BLOCK { + PNDIS_MINIPORT_BLOCK MiniportQueue; // queue of mini-ports for this driver + NDIS_HANDLE MiniportIdField; + + REFERENCE Ref; // contains spinlock for MiniportQueue + UINT Length; // of this NDIS_DRIVER_BLOCK structure + NDIS_MINIPORT_CHARACTERISTICS MiniportCharacteristics; // handler addresses + PNDIS_WRAPPER_HANDLE NdisDriverInfo; // Driver information. + PNDIS_M_DRIVER_BLOCK NextDriver; + PNDIS_MAC_BLOCK FakeMac; + KEVENT MiniportsRemovedEvent; // used to find when all mini-ports are gone. + BOOLEAN Unloading; // TRUE if unloading + +}; + +typedef struct _NDIS_MINIPORT_INTERRUPT { + PKINTERRUPT InterruptObject; + KSPIN_LOCK DpcCountLock; + PVOID MiniportIdField; + W_ISR_HANDLER MiniportIsr; + W_HANDLE_INTERRUPT_HANDLER MiniportDpc; + KDPC InterruptDpc; + PNDIS_MINIPORT_BLOCK Miniport; + UCHAR DpcCount; + BOOLEAN Filler1; + + // + // This is used to tell when all the Dpcs for the adapter are completed. + // + + KEVENT DpcsCompletedEvent; + + BOOLEAN SharedInterrupt; + BOOLEAN IsrRequested; + +} NDIS_MINIPORT_INTERRUPT, *PNDIS_MINIPORT_INTERRUPT; + + +typedef struct _NDIS_MINIPORT_TIMER { + KTIMER Timer; + KDPC Dpc; + PNDIS_TIMER_FUNCTION MiniportTimerFunction; + PVOID MiniportTimerContext; + PNDIS_MINIPORT_BLOCK Miniport; + struct _NDIS_MINIPORT_TIMER *NextDeferredTimer; +} NDIS_MINIPORT_TIMER, *PNDIS_MINIPORT_TIMER; + +// +// Pending NdisOpenAdapter() structure (for miniports only). +// + +typedef struct _MINIPORT_PENDING_OPEN *PMINIPORT_PENDING_OPEN; + +typedef struct _MINIPORT_PENDING_OPEN { + + PMINIPORT_PENDING_OPEN NextPendingOpen; + PNDIS_HANDLE NdisBindingHandle; + PNDIS_MINIPORT_BLOCK Miniport; + PVOID NewOpenP; + PVOID FileObject; + NDIS_HANDLE NdisProtocolHandle; + NDIS_HANDLE ProtocolBindingContext; + PNDIS_STRING AdapterName; + UINT OpenOptions; + PSTRING AddressingInformation; + BOOLEAN UsingEncapsulation; +} MINIPORT_PENDING_OPEN; + + +// +// one of these per mini-port registered on a Driver +// + +struct _NDIS_MINIPORT_BLOCK { + ULONG Flags; // used to distinquish between MACs and mini-ports + PDEVICE_OBJECT DeviceObject; // created by the wrapper + PNDIS_M_DRIVER_BLOCK DriverHandle; // pointer to our Driver block + NDIS_HANDLE MiniportAdapterContext; // context when calling mini-port functions + NDIS_STRING MiniportName; // how mini-port refers to us + PNDIS_M_OPEN_BLOCK OpenQueue; // queue of opens for this mini-port + PNDIS_MINIPORT_BLOCK NextMiniport; // used by driver's MiniportQueue + REFERENCE Ref; // contains spinlock for OpenQueue + BOOLEAN NormalInterrupts; + BOOLEAN ProcessingDeferred; // TRUE if processing deferred operations + + // + // Synchronization stuff. + // + // The boolean is used to lock out several DPCs from running at the + // same time. The difficultly is if DPC A releases the spin lock + // and DPC B tries to run, we want to defer B until after A has + // exited. + // + BOOLEAN LockAcquired; + NDIS_SPIN_LOCK Lock; + PNDIS_MINIPORT_INTERRUPT Interrupt; + + // + // Stuff that got deferred. + // + BOOLEAN RunDpc; + BOOLEAN Timeout; + BOOLEAN InAddDriver; + BOOLEAN InInitialize; + PNDIS_MINIPORT_TIMER RunTimer; + NDIS_TIMER DpcTimer; + NDIS_TIMER WakeUpDpcTimer; + + // + // Holds media specific information + // + PETH_FILTER EthDB; + PTR_FILTER TrDB; + PFDDI_FILTER FddiDB; + PARC_FILTER ArcDB; + NDIS_MEDIUM MediaType; + + UCHAR TrResetRing; + UCHAR ArcnetAddress; + BOOLEAN ArcnetBroadcastSet; + BOOLEAN SendCompleteCalled; + + PVOID WrapperContext; + + NDIS_HANDLE ArcnetBufferPool; + PARC_BUFFER_LIST ArcnetFreeBufferList; + PARC_BUFFER_LIST ArcnetUsedBufferList; + + // + // Resource information + // + PCM_RESOURCE_LIST Resources; + + // + // contains mini-port information + // + ULONG BusNumber; + NDIS_INTERFACE_TYPE BusType; + NDIS_INTERFACE_TYPE AdapterType; + BOOLEAN Master; + + // + // Holds the map registers for this mini-port. + // + BOOLEAN Dma32BitAddresses; + PMAP_REGISTER_ENTRY MapRegisters; + ULONG PhysicalMapRegistersNeeded; + ULONG MaximumPhysicalMapping; + + // + // These two are used temporarily while allocating + // the map registers. + // + KEVENT AllocationEvent; + UINT CurrentMapRegister; + PADAPTER_OBJECT SystemAdapterObject; + + // + // Send information + // + PNDIS_PACKET FirstPacket; // This pointer serves two purposes; + // it is the head of the queue of ALL + // packets that have been sent to + // the miniport, it is also the head + // of the packets that have been sent + // down to the miniport by the wrapper. + PNDIS_PACKET LastPacket; // This is tail pointer for the global + // packet queue and this is the tail + // pointer to the queue of packets + // waiting to be sent to the miniport. + PNDIS_PACKET FirstPendingPacket; // This is head of the queue of packets + // waiting to be sent to miniport. + PNDIS_PACKET LastMiniportPacket; // This is the tail pointer of the + // queue of packets that have been + // sent to the miniport by the wrapper. + ULONG SendResourcesAvailable; + PNDIS_PACKET DeadPacket; // This pointer is used by the wake-up + // dpc to make sure that a packet that + // was sent to the miniport has been + // completed with-in a decent amount + // of time. + BOOLEAN AlreadyLoopedBack; // This flag is set if a packet that + // is waiting to be sent to the + // miniport has already been looped- + // back; + + + // + // Transfer data information + // + PNDIS_PACKET FirstTDPacket; + PNDIS_PACKET LastTDPacket; + PNDIS_PACKET LoopbackPacket; + UINT LoopbackPacketHeaderSize; + + // + // Reset information + // + PNDIS_M_OPEN_BLOCK ResetRequested; + PNDIS_M_OPEN_BLOCK ResetInProgress; + + // + // RequestInformation + // + KEVENT RequestEvent; + PNDIS_REQUEST FirstPendingRequest; + PNDIS_REQUEST LastPendingRequest; + PNDIS_REQUEST MiniportRequest; + NDIS_REQUEST InternalRequest; + NDIS_STATUS RequestStatus; + UINT MaximumLongAddresses; + UINT MaximumShortAddresses; + UINT CurrentLookahead; + UINT MaximumLookahead; + UINT MacOptions; + ULONG SupportedPacketFilters; + BOOLEAN NeedToUpdateEthAddresses; + BOOLEAN NeedToUpdatePacketFilter; + BOOLEAN NeedToUpdateFunctionalAddress; + BOOLEAN NeedToUpdateGroupAddress; + BOOLEAN NeedToUpdateFddiLongAddresses; + BOOLEAN NeedToUpdateFddiShortAddresses; + BOOLEAN RunDoRequests; + BOOLEAN ProcessOddDeferredStuff; + UCHAR MulticastBuffer[NDIS_M_MAX_MULTI_LIST][6]; + UCHAR LookaheadBuffer[NDIS_M_MAX_LOOKAHEAD]; + + BOOLEAN BeingRemoved; // TRUE if mini-port is being removed + BOOLEAN HaltingMiniport; // TRUE if mini-port halt handler needs to be called + + // + // Temp stuff for using the old NDIS functions + // + ULONG ChannelNumber; + + PMINIPORT_PENDING_OPEN FirstPendingOpen; + PMINIPORT_PENDING_OPEN LastPendingOpen; + BOOLEAN PendingRequestTimeout; +}; + +#define MINIPORT_LOCK_ACQUIRED(_Miniport) ((_Miniport)->LockAcquired) + + +// +// one of these per open on an mini-port/protocol +// + +struct _NDIS_M_OPEN_BLOCK { + PNDIS_M_DRIVER_BLOCK DriverHandle; // pointer to our driver + PNDIS_MINIPORT_BLOCK MiniportHandle; // pointer to our mini-port + PNDIS_PROTOCOL_BLOCK ProtocolHandle; // pointer to our protocol + PNDIS_OPEN_BLOCK FakeOpen; // Pointer to fake open block + NDIS_HANDLE ProtocolBindingContext; // context when calling ProtXX funcs + NDIS_HANDLE MiniportAdapterContext; // context when calling MiniportXX funcs + PNDIS_M_OPEN_BLOCK MiniportNextOpen; // used by mini-port's OpenQueue + PFILE_OBJECT FileObject; // created by operating system + BOOLEAN Closing; // TRUE when removing this struct + BOOLEAN UsingEthEncapsulation; // TRUE if running 802.3 on 878.2 + NDIS_HANDLE CloseRequestHandle; // 0 indicates an internal close + NDIS_HANDLE FilterHandle; + NDIS_SPIN_LOCK SpinLock; // guards Closing + ULONG References; + UINT CurrentLookahead; + ULONG ProtocolOptions; + + // + // These are optimizations for getting to driver routines. They are not + // necessary, but are here to save a dereference through the Driver block. + // + + W_SEND_HANDLER SendHandler; + W_TRANSFER_DATA_HANDLER TransferDataHandler; + + // + // These are optimizations for getting to PROTOCOL routines. They are not + // necessary, but are here to save a dereference through the PROTOCOL block. + // + + SEND_COMPLETE_HANDLER SendCompleteHandler; + TRANSFER_DATA_COMPLETE_HANDLER TransferDataCompleteHandler; + RECEIVE_HANDLER ReceiveHandler; + RECEIVE_COMPLETE_HANDLER ReceiveCompleteHandler; + +}; + +// +// NOTE: THIS STRUCTURE MUST, MUST, MUST ALIGN WITH THE +// NDIS_USER_OPEN_CONTEXT STRUCTURE defined in the wrapper. +// +typedef struct _NDIS_M_USER_OPEN_CONTEXT { + PDEVICE_OBJECT DeviceObject; + PNDIS_MINIPORT_BLOCK MiniportBlock; + ULONG OidCount; + PNDIS_OID OidArray; +} NDIS_M_USER_OPEN_CONTEXT, *PNDIS_M_USER_OPEN_CONTEXT; + + +typedef struct _NDIS_REQUEST_RESERVED { + PNDIS_REQUEST Next; + struct _NDIS_M_OPEN_BLOCK * Open; +} NDIS_REQUEST_RESERVED, *PNDIS_REQUEST_RESERVED; + +#define PNDIS_RESERVED_FROM_PNDIS_REQUEST(_request) \ + ((PNDIS_REQUEST_RESERVED)((_request)->MacReserved)) + + +BOOLEAN +NdisMIsr( + IN PKINTERRUPT KInterrupt, + IN PVOID Context + ); + +VOID +NdisMDpc( + IN PVOID SystemSpecific1, + IN PVOID InterruptContext, + IN PVOID SystemSpecific2, + IN PVOID SystemSpecific3 + ); + +VOID +NdisMDpcTimer( + IN PVOID SystemSpecific1, + IN PVOID InterruptContext, + IN PVOID SystemSpecific2, + IN PVOID SystemSpecific3 + ); + +VOID +NdisMWakeUpDpc( + PKDPC Dpc, + PVOID Context, + PVOID SystemContext1, + PVOID SystemContext2 + ); + +NDIS_STATUS +NdisMChangeEthAddresses( + IN UINT OldAddressCount, + IN CHAR OldAddresses[][6], + IN UINT NewAddressCount, + IN CHAR NewAddresses[][6], + IN NDIS_HANDLE MacBindingHandle, + IN PNDIS_REQUEST NdisRequest, + IN BOOLEAN Set + ); + +NDIS_STATUS +NdisMChangeClass( + IN UINT OldFilterClasses, + IN UINT NewFilterClasses, + IN NDIS_HANDLE MacBindingHandle, + IN PNDIS_REQUEST NdisRequest, + IN BOOLEAN Set + ); + +VOID +NdisMCloseAction( + IN NDIS_HANDLE MacBindingHandle + ); + +NDIS_STATUS +NdisMChangeFunctionalAddress( + IN TR_FUNCTIONAL_ADDRESS OldFunctionalAddress, + IN TR_FUNCTIONAL_ADDRESS NewFunctionalAddress, + IN NDIS_HANDLE MacBindingHandle, + IN PNDIS_REQUEST NdisRequest, + IN BOOLEAN Set + ); + +NDIS_STATUS +NdisMChangeGroupAddress( + IN TR_FUNCTIONAL_ADDRESS OldGroupAddress, + IN TR_FUNCTIONAL_ADDRESS NewGroupAddress, + IN NDIS_HANDLE MacBindingHandle, + IN PNDIS_REQUEST NdisRequest, + IN BOOLEAN Set + ); + +NDIS_STATUS +NdisMChangeFddiAddresses( + IN UINT oldLongAddressCount, + IN CHAR oldLongAddresses[][6], + IN UINT newLongAddressCount, + IN CHAR newLongAddresses[][6], + IN UINT oldShortAddressCount, + IN CHAR oldShortAddresses[][2], + IN UINT newShortAddressCount, + IN CHAR newShortAddresses[][2], + IN NDIS_HANDLE MacBindingHandle, + IN PNDIS_REQUEST NdisRequest, + IN BOOLEAN Set + ); + +NDIS_STATUS +NdisMSend( + IN NDIS_HANDLE NdisBindingHandle, + IN PNDIS_PACKET Packet + ); + +NDIS_STATUS +NdisMTransferData( + IN NDIS_HANDLE NdisBindingHandle, + IN NDIS_HANDLE MacReceiveContext, + IN UINT ByteOffset, + IN UINT BytesToTransfer, + IN OUT PNDIS_PACKET Packet, + OUT PUINT BytesTransferred + ); + +NDIS_STATUS +NdisMArcTransferData( + IN NDIS_HANDLE NdisBindingHandle, + IN NDIS_HANDLE MacReceiveContext, + IN UINT ByteOffset, + IN UINT BytesToTransfer, + IN OUT PNDIS_PACKET Packet, + OUT PUINT BytesTransferred + ); + +NDIS_STATUS +NdisMReset( + IN NDIS_HANDLE NdisBindingHandle + ); + +NDIS_STATUS +NdisMRequest( + IN NDIS_HANDLE NdisBindingHandle, + IN PNDIS_REQUEST NdisRequest + ); + + +// +// Operating System Requests +// + +EXPORT +NDIS_STATUS +NdisMAllocateMapRegisters( + IN NDIS_HANDLE MiniportAdapterHandle, + IN UINT DmaChannel, + IN BOOLEAN Dma32BitAddresses, + IN ULONG PhysicalMapRegistersNeeded, + IN ULONG MaximumPhysicalMapping + ); + +EXPORT +VOID +NdisMFreeMapRegisters( + IN NDIS_HANDLE MiniportAdapterHandle + ); + +EXPORT +NDIS_STATUS +NdisMRegisterIoPortRange( + OUT PVOID *PortOffset, + IN NDIS_HANDLE MiniportAdapterHandle, + IN UINT InitialPort, + IN UINT NumberOfPorts + ); + +EXPORT +VOID +NdisMDeregisterIoPortRange( + IN NDIS_HANDLE MiniportAdapterHandle, + IN UINT InitialPort, + IN UINT NumberOfPorts, + IN PVOID PortOffset + ); + +EXPORT +NDIS_STATUS +NdisMMapIoSpace( + OUT PVOID * VirtualAddress, + IN NDIS_HANDLE MiniportAdapterHandle, + IN NDIS_PHYSICAL_ADDRESS PhysicalAddress, + IN UINT Length + ); + +EXPORT +VOID +NdisMUnmapIoSpace( + IN NDIS_HANDLE MiniportAdapterHandle, + IN PVOID VirtualAddress, + IN UINT Length + ); + +EXPORT +NDIS_STATUS +NdisMRegisterInterrupt( + OUT PNDIS_MINIPORT_INTERRUPT Interrupt, + IN NDIS_HANDLE MiniportAdapterHandle, + IN UINT InterruptVector, + IN UINT InterruptLevel, + IN BOOLEAN RequestIsr, + IN BOOLEAN SharedInterrupt, + IN NDIS_INTERRUPT_MODE InterruptMode + ); + +EXPORT +VOID +NdisMDeregisterInterrupt( + IN PNDIS_MINIPORT_INTERRUPT Interrupt + ); + +EXPORT +BOOLEAN +NdisMSynchronizeWithInterrupt( + IN PNDIS_MINIPORT_INTERRUPT Interrupt, + IN PVOID SynchronizeFunction, + IN PVOID SynchronizeContext + ); + + +EXPORT +NDIS_STATUS +NdisMQueryAdapterResources( + OUT PNDIS_STATUS Status, + IN NDIS_HANDLE WrapperConfigurationContext, + OUT PNDIS_RESOURCE_LIST ResourceList, + IN OUT PUINT BufferSize + ); + +// +// Timers +// + +/*++ +VOID +NdisMSetTimer( + IN PNDIS_MINIPORT_TIMER Timer, + IN UINT MillisecondsToDelay + ); +--*/ +#define NdisMSetTimer(_Timer, _Delay) NdisSetTimer((PNDIS_TIMER)(_Timer), _Delay) + +EXPORT +VOID +NdisMInitializeTimer( + IN OUT PNDIS_MINIPORT_TIMER Timer, + IN NDIS_HANDLE MiniportAdapterHandle, + IN PNDIS_TIMER_FUNCTION TimerFunction, + IN PVOID FunctionContext + ); + +EXPORT +VOID +NdisMCancelTimer( + IN PNDIS_MINIPORT_TIMER Timer, + OUT PBOOLEAN TimerCancelled + ); + +// +// Physical Mapping +// + +#define NdisMStartBufferPhysicalMappingMacro( \ + _MiniportAdapterHandle, \ + _Buffer, \ + _PhysicalMapRegister, \ + _Write, \ + _PhysicalAddressArray, \ + _ArraySize \ + ) \ +{ \ + PNDIS_MINIPORT_BLOCK _Miniport = (PNDIS_MINIPORT_BLOCK)(_MiniportAdapterHandle); \ + PHYSICAL_ADDRESS _LogicalAddress; \ + PUCHAR _VirtualAddress; \ + ULONG _LengthRemaining; \ + ULONG _LengthMapped; \ + UINT _CurrentArrayLocation; \ + _VirtualAddress = MmGetMdlVirtualAddress(_Buffer); \ + _LengthRemaining = MmGetMdlByteCount(_Buffer); \ + _CurrentArrayLocation = 0; \ + while (_LengthRemaining > 0) { \ + _LengthMapped = _LengthRemaining; \ + _LogicalAddress = \ + IoMapTransfer( \ + NULL, \ + (_Buffer), \ + _Miniport->MapRegisters[_PhysicalMapRegister].MapRegister, \ + _VirtualAddress, \ + &_LengthMapped, \ + (_Write)); \ + (_PhysicalAddressArray)[_CurrentArrayLocation].PhysicalAddress = _LogicalAddress; \ + (_PhysicalAddressArray)[_CurrentArrayLocation].Length = _LengthMapped; \ + _LengthRemaining -= _LengthMapped; \ + _VirtualAddress += _LengthMapped; \ + ++_CurrentArrayLocation; \ + } \ + _Miniport->MapRegisters[_PhysicalMapRegister].WriteToDevice = (_Write); \ + *(_ArraySize) = _CurrentArrayLocation; \ +} + +#if BINARY_COMPATIBLE + +EXPORT +VOID +NdisMStartBufferPhysicalMapping( + IN NDIS_HANDLE MiniportAdapterHandle, + IN PNDIS_BUFFER Buffer, + IN ULONG PhysicalMapRegister, + IN BOOLEAN WriteToDevice, + OUT PNDIS_PHYSICAL_ADDRESS_UNIT PhysicalAddressArray, + OUT PUINT ArraySize + ); + +#else + +#define NdisMStartBufferPhysicalMapping( \ + _MiniportAdapterHandle, \ + _Buffer, \ + _PhysicalMapRegister, \ + _Write, \ + _PhysicalAddressArray, \ + _ArraySize \ + ) \ + NdisMStartBufferPhysicalMappingMacro( \ + (_MiniportAdapterHandle), \ + (_Buffer), \ + (_PhysicalMapRegister), \ + (_Write), \ + (_PhysicalAddressArray), \ + (_ArraySize) \ + ) + +#endif + +#define NdisMCompleteBufferPhysicalMappingMacro( \ + _MiniportAdapterHandle, \ + _Buffer, \ + _PhysicalMapRegister \ + ) { \ + PNDIS_MINIPORT_BLOCK _Miniport = (PNDIS_MINIPORT_BLOCK)(_MiniportAdapterHandle); \ + IoFlushAdapterBuffers( \ + NULL, \ + _Buffer, \ + _Miniport->MapRegisters[_PhysicalMapRegister].MapRegister, \ + MmGetMdlVirtualAddress(_Buffer), \ + MmGetMdlByteCount(_Buffer), \ + _Miniport->MapRegisters[_PhysicalMapRegister].WriteToDevice); \ +} + +#if BINARY_COMPATIBLE + +EXPORT +VOID +NdisMCompleteBufferPhysicalMapping( + IN NDIS_HANDLE MiniportAdapterHandle, + IN PNDIS_BUFFER Buffer, + IN ULONG PhysicalMapRegister + ); + +#else + +#define NdisMCompleteBufferPhysicalMapping( \ + _MiniportAdapterHandle, \ + _Buffer, \ + _PhysicalMapRegister \ + ) \ + NdisMCompleteBufferPhysicalMappingMacro( \ + (_MiniportAdapterHandle), \ + (_Buffer), \ + (_PhysicalMapRegister) \ + ) + +#endif + +// +// Shared memory +// + +EXPORT +VOID +NdisMAllocateSharedMemory( + IN NDIS_HANDLE MiniportAdapterHandle, + IN ULONG Length, + IN BOOLEAN Cached, + OUT PVOID *VirtualAddress, + OUT PNDIS_PHYSICAL_ADDRESS PhysicalAddress + ); + +/*++ +VOID +NdisMUpdateSharedMemory( + IN NDIS_HANDLE MiniportAdapterHandle, + IN ULONG Length, + IN PVOID VirtualAddress, + IN NDIS_PHYSICAL_ADDRESS PhysicalAddress + ) +--*/ +#define NdisMUpdateSharedMemory(_H, _L, _V, _P) NdisUpdateSharedMemory(_H, _L, _V, _P) + + +EXPORT +VOID +NdisMFreeSharedMemory( + IN NDIS_HANDLE MiniportAdapterHandle, + IN ULONG Length, + IN BOOLEAN Cached, + IN PVOID VirtualAddress, + IN NDIS_PHYSICAL_ADDRESS PhysicalAddress + ); + + +// +// DMA operations. +// + +EXPORT +NDIS_STATUS +NdisMRegisterDmaChannel( + OUT PNDIS_HANDLE MiniportDmaHandle, + IN NDIS_HANDLE MiniportAdapterHandle, + IN UINT DmaChannel, + IN BOOLEAN Dma32BitAddresses, + IN PNDIS_DMA_DESCRIPTION DmaDescription, + IN ULONG MaximumLength + ); + + +EXPORT +VOID +NdisMDeregisterDmaChannel( + IN PNDIS_HANDLE MiniportDmaHandle + ); + +/*++ +VOID +NdisMSetupDmaTransfer( + OUT PNDIS_STATUS Status, + IN PNDIS_HANDLE MiniportDmaHandle, + IN PNDIS_BUFFER Buffer, + IN ULONG Offset, + IN ULONG Length, + IN BOOLEAN WriteToDevice + ) +--*/ +#define NdisMSetupDmaTransfer(_S, _H, _B, _O, _L, _M_) \ + NdisSetupDmaTransfer(_S, _H, _B, _O, _L, _M_) + +/*++ +VOID +NdisMCompleteDmaTransfer( + OUT PNDIS_STATUS Status, + IN PNDIS_HANDLE MiniportDmaHandle, + IN PNDIS_BUFFER Buffer, + IN ULONG Offset, + IN ULONG Length, + IN BOOLEAN WriteToDevice + ) +--*/ +#define NdisMCompleteDmaTransfer(_S, _H, _B, _O, _L, _M_) \ + NdisCompleteDmaTransfer(_S, _H, _B, _O, _L, _M_) + +EXPORT +ULONG +NdisMReadDmaCounter( + IN NDIS_HANDLE MiniportDmaHandle + ); + + +// +// Requests Used by Miniport Drivers +// + + +#define NdisMInitializeWrapper(_a,_b,_c,_d) NdisInitializeWrapper((_a),(_b),(_c),(_d)) + +EXPORT +NDIS_STATUS +NdisMRegisterMiniport( + IN NDIS_HANDLE NdisWrapperHandle, + IN PNDIS_MINIPORT_CHARACTERISTICS MiniportCharacteristics, + IN UINT CharacteristicsLength + ); + +EXPORT +VOID +NdisMSetAttributes( + IN NDIS_HANDLE MiniportAdapterHandle, + IN NDIS_HANDLE MiniportAdapterContext, + IN BOOLEAN BusMaster, + IN NDIS_INTERFACE_TYPE AdapterType + ); + +EXPORT +VOID +NdisMSendComplete( + IN NDIS_HANDLE MiniportAdapterHandle, + IN PNDIS_PACKET Packet, + IN NDIS_STATUS Status + ); + +EXPORT +VOID +NdisMSendResourcesAvailable( + IN NDIS_HANDLE MiniportAdapterHandle + ); + +EXPORT +VOID +NdisMTransferDataComplete( + IN NDIS_HANDLE MiniportAdapterHandle, + IN PNDIS_PACKET Packet, + IN NDIS_STATUS Status, + IN UINT BytesTransferred + ); + +EXPORT +VOID +NdisMResetComplete( + IN NDIS_HANDLE MiniportAdapterHandle, + IN NDIS_STATUS Status, + IN BOOLEAN AddressingReset + ); + +EXPORT +VOID +NdisMSetInformationComplete( + IN NDIS_HANDLE MiniportAdapterHandle, + IN NDIS_STATUS Status + ); + +EXPORT +VOID +NdisMQueryInformationComplete( + IN NDIS_HANDLE MiniportAdapterHandle, + IN NDIS_STATUS Status + ); + + +/*++ + +VOID +NdisMEthIndicateReceive( + IN NDIS_HANDLE MiniportAdapterHandle, + IN NDIS_HANDLE MiniportReceiveContext, + IN PVOID HeaderBuffer, + IN UINT HeaderBufferSize, + IN PVOID LookaheadBuffer, + IN UINT LookaheadBufferSize, + IN UINT PacketSize + ) + +--*/ +#define NdisMEthIndicateReceive( _H, _C, _B, _SZ, _L, _LSZ, _PSZ ) \ +{ \ + ASSERT(MINIPORT_LOCK_ACQUIRED((PNDIS_MINIPORT_BLOCK)(_H))); \ + EthFilterDprIndicateReceive( \ + ((PNDIS_MINIPORT_BLOCK)(_H))->EthDB, \ + _C, \ + _B, \ + _B, \ + _SZ, \ + _L, \ + _LSZ, \ + _PSZ \ + ); \ +} + +/*++ + +VOID +NdisMTrIndicateReceive( + IN NDIS_HANDLE MiniportAdapterHandle, + IN NDIS_HANDLE MiniportReceiveContext, + IN PVOID HeaderBuffer, + IN UINT HeaderBufferSize, + IN PVOID LookaheadBuffer, + IN UINT LookaheadBufferSize, + IN UINT PacketSize + ) + +--*/ +#define NdisMTrIndicateReceive( _H, _C, _B, _SZ, _L, _LSZ, _PSZ ) \ +{ \ + ASSERT(MINIPORT_LOCK_ACQUIRED((PNDIS_MINIPORT_BLOCK)(_H))); \ + TrFilterDprIndicateReceive( \ + ((PNDIS_MINIPORT_BLOCK)(_H))->TrDB, \ + _C, \ + _B, \ + _SZ, \ + _L, \ + _LSZ, \ + _PSZ \ + ); \ +} + +/*++ + +VOID +NdisMFddiIndicateReceive( + IN NDIS_HANDLE MiniportAdapterHandle, + IN NDIS_HANDLE MiniportReceiveContext, + IN PVOID HeaderBuffer, + IN UINT HeaderBufferSize, + IN PVOID LookaheadBuffer, + IN UINT LookaheadBufferSize, + IN UINT PacketSize + ) + +--*/ + +#define NdisMFddiIndicateReceive( _H, _C, _B, _SZ, _L, _LSZ, _PSZ ) \ +{ \ + ASSERT(MINIPORT_LOCK_ACQUIRED((PNDIS_MINIPORT_BLOCK)(_H))); \ + \ + FddiFilterDprIndicateReceive( \ + ((PNDIS_MINIPORT_BLOCK)(_H))->FddiDB, \ + _C, \ + (PUCHAR)_B + 1, \ + ((((PUCHAR)_B)[0] & 0x40) ? FDDI_LENGTH_OF_LONG_ADDRESS \ + : FDDI_LENGTH_OF_SHORT_ADDRESS), \ + _B, \ + _SZ, \ + _L, \ + _LSZ, \ + _PSZ \ + ); \ +} + +/*++ + +VOID +NdisMArcIndicateReceive( + IN NDIS_HANDLE MiniportAdapterHandle, + IN PUCHAR pRawHeader, // Pointer to Arcnet frame header + IN PUCHAR pData, // Pointer to data portion of Arcnet frame + IN UINT Length // Data Length + ) + +--*/ +#define NdisMArcIndicateReceive( _H, _HD, _D, _SZ) \ +{ \ + ASSERT(MINIPORT_LOCK_ACQUIRED((PNDIS_MINIPORT_BLOCK)(_H))); \ + ArcFilterDprIndicateReceive( \ + ((PNDIS_MINIPORT_BLOCK)(_H))->ArcDB, \ + _HD, \ + _D, \ + _SZ \ + ); \ +} + +// +// Used only internally by the wrapper and filter package. +// +VOID +NdisMArcIndicateEthEncapsulatedReceive( + IN PNDIS_MINIPORT_BLOCK Miniport, + IN PVOID HeaderBuffer, + IN PVOID DataBuffer, + IN UINT Length + ); + + + + +/*++ + +VOID +NdisMEthIndicateReceiveComplete( + IN NDIS_HANDLE MiniportAdapterHandle + ); + +--*/ + +#define NdisMEthIndicateReceiveComplete( _H ) \ +{ \ + PNDIS_MINIPORT_BLOCK _M_ = (PNDIS_MINIPORT_BLOCK)_H; \ + ASSERT(MINIPORT_LOCK_ACQUIRED(_M_)); \ + EthFilterDprIndicateReceiveComplete(_M_->EthDB); \ +} + +/*++ + +VOID +NdisMTrIndicateReceiveComplete( + IN NDIS_HANDLE MiniportAdapterHandle + ); + +--*/ + +#define NdisMTrIndicateReceiveComplete( _H ) \ +{ \ + PNDIS_MINIPORT_BLOCK _M_ = (PNDIS_MINIPORT_BLOCK)_H; \ + ASSERT(MINIPORT_LOCK_ACQUIRED(_M_)); \ + TrFilterDprIndicateReceiveComplete(_M_->TrDB); \ +} + +/*++ + +VOID +NdisMFddiIndicateReceiveComplete( + IN NDIS_HANDLE MiniportAdapterHandle + ); + +--*/ + +#define NdisMFddiIndicateReceiveComplete( _H ) \ +{ \ + PNDIS_MINIPORT_BLOCK _M_ = (PNDIS_MINIPORT_BLOCK)_H; \ + ASSERT(MINIPORT_LOCK_ACQUIRED(_M_)); \ + FddiFilterDprIndicateReceiveComplete(_M_->FddiDB); \ +} + +/*++ + +VOID +NdisMArcIndicateReceiveComplete( + IN NDIS_HANDLE MiniportAdapterHandle + ); + +--*/ + +#define NdisMArcIndicateReceiveComplete( _H ) \ +{ \ + PNDIS_MINIPORT_BLOCK _M_ = (PNDIS_MINIPORT_BLOCK)_H; \ + ASSERT(MINIPORT_LOCK_ACQUIRED(_M_)); \ + \ + if ( _M_->EthDB ) { \ + EthFilterDprIndicateReceiveComplete(_M_->EthDB); \ + } \ + \ + ArcFilterDprIndicateReceiveComplete(_M_->ArcDB); \ +} + +EXPORT +VOID +NdisMIndicateStatus( + IN NDIS_HANDLE MiniportAdapterHandle, + IN NDIS_STATUS GeneralStatus, + IN PVOID StatusBuffer, + IN UINT StatusBufferSize + ); + +EXPORT +VOID +NdisMIndicateStatusComplete( + IN NDIS_HANDLE MiniportAdapterHandle + ); + +EXPORT +VOID +NdisMRegisterAdapterShutdownHandler( + IN NDIS_HANDLE MiniportHandle, + IN PVOID ShutdownContext, + IN ADAPTER_SHUTDOWN_HANDLER ShutdownHandler + ); + +EXPORT +VOID +NdisMDeregisterAdapterShutdownHandler( + IN NDIS_HANDLE MiniportHandle + ); + +EXPORT +NDIS_STATUS +NdisMPciAssignResources( + IN NDIS_HANDLE MiniportHandle, + IN ULONG SlotNumber, + IN PNDIS_RESOURCE_LIST *AssignedResources + ); + + |