#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
    );