/*++ Copyright (c) 1992 Microsoft Corporation Module Name: priv.h Abstract: Common header file for ATM Epvc IM miniport. Author: ADube 03/23/2000 Environment: Revision History: --*/ #ifndef _PRIV_H #define _PRIV_H //advance declaration typedef struct _EPVC_I_MINIPORT _ADAPT, ADAPT, *PADAPT; typedef struct _EPVC_I_MINIPORT EPVC_I_MINIPORT, *PEPVC_I_MINIPORT ; typedef struct _EPVC_GLOBALS EPVC_GLOBALS, *PEPVC_GLOBALS; typedef struct _EPVC_ARP_PACKET EPVC_ARP_PACKET, *PEPVC_ARP_PACKET ; typedef struct _EPVC_NDIS_REQUEST EPVC_NDIS_REQUEST, *PEPVC_NDIS_REQUEST; extern LIST_ENTRY g_ProtocolList; // // Temp declarations // extern NDIS_HANDLE ProtHandle, DriverHandle; extern EPVC_GLOBALS EpvcGlobals; //-------------------------------------------------------------------------------- // // // Driver Functions - Prototypes // // // // // //-------------------------------------------------------------------------------- extern NTSTATUS DriverEntry( IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath ); extern VOID EpvcUnload( IN PDRIVER_OBJECT pDriverObject ); //-------------------------------------------------------------------------------- // // // Protocol Functions - Prototypes // // // // // //-------------------------------------------------------------------------------- extern VOID EpvcResetComplete( IN NDIS_HANDLE ProtocolBindingContext, IN NDIS_STATUS Status ); extern VOID PtStatus( IN NDIS_HANDLE ProtocolBindingContext, IN NDIS_STATUS GeneralStatus, IN PVOID StatusBuffer, IN UINT StatusBufferSize ); extern VOID PtStatusComplete( IN NDIS_HANDLE ProtocolBindingContext ); extern VOID PtTransferDataComplete( IN NDIS_HANDLE ProtocolBindingContext, IN PNDIS_PACKET Packet, IN NDIS_STATUS Status, IN UINT BytesTransferred ); extern NDIS_STATUS PtReceive( IN NDIS_HANDLE ProtocolBindingContext, IN NDIS_HANDLE MacReceiveContext, IN PVOID HeaderBuffer, IN UINT HeaderBufferSize, IN PVOID LookAheadBuffer, IN UINT LookaheadBufferSize, IN UINT PacketSize ); extern VOID PtReceiveComplete( IN NDIS_HANDLE ProtocolBindingContext ); extern INT PtReceivePacket( IN NDIS_HANDLE ProtocolBindingContext, IN PNDIS_PACKET Packet ); VOID EpvcUnload( IN PDRIVER_OBJECT DriverObject ); extern VOID EpvcAfRegisterNotify( IN NDIS_HANDLE ProtocolBindingContext, IN PCO_ADDRESS_FAMILY AddressFamily ); VOID epvcOidCloseAfWorkItem( IN PRM_OBJECT_HEADER pObj, IN NDIS_STATUS Status, IN PRM_STACK_RECORD pSR ); //-------------------------------------------------------------------------------- // // // Miniport Functions - Prototypes // // // // // //-------------------------------------------------------------------------------- NDIS_STATUS MPTransferData( OUT PNDIS_PACKET Packet, OUT PUINT BytesTransferred, IN NDIS_HANDLE MiniportAdapterContext, IN NDIS_HANDLE MiniportReceiveContext, IN UINT ByteOffset, IN UINT BytesToTransfer ); NDIS_STATUS MPReset( OUT PBOOLEAN AddressingReset, IN NDIS_HANDLE MiniportAdapterContext ); #define DBGPRINT(Fmt) \ { \ DbgPrint("*** %s (%d) *** ", __FILE__, __LINE__); \ DbgPrint (Fmt); \ } #define NUM_PKTS_IN_POOL 256 extern NDIS_PHYSICAL_ADDRESS HighestAcceptableMax; extern NDIS_HANDLE ProtHandle, DriverHandle; extern NDIS_MEDIUM MediumArray[1]; // // Custom Macros to be used by the passthru driver // /* bool IsIMDeviceStateOn( PADAPT ) */ #define IsIMDeviceStateOn(_pP) ((_pP)->MPDeviceState == NdisDeviceStateD0 && (_pP)->PTDeviceState == NdisDeviceStateD0 ) //-------------------------------------------------------------------------------- // // // New stuff for atmepvc starts here // // // // // //-------------------------------------------------------------------------------- //----------------------------------------------------------------------------------- // // // Arp Packet Parsing structs // // // //----------------------------------------------------------------------------------- // // Len of an Ethernet Header. // #define ARP_802_ADDR_LENGTH 6 // // HwType should be one of the two below. // #define ARP_HW_ENET 1 #define ARP_HW_802 6 // // Ip Address // typedef ULONG IP_ADDR; #define ARP_ETYPE_ARP 0x806 #define ARP_REQUEST 1 #define ARP_RESPONSE 2 #define ARP_HW_ENET 1 #define IP_PROT_TYPE 0x800 // // As these data structs are used to parse data off the wire. // make sure it is packed at 1 // #pragma pack( push, enter_include1, 1 ) // // The following object is a convenient way to // store and access an IEEE 48-bit MAC address. // typedef struct _MAC_ADDRESS { UCHAR Byte[ARP_802_ADDR_LENGTH]; } MAC_ADDRESS, *PMAC_ADDRESS; // // Structure of the Ethernet Arp packet. The 14 byte ethernet header is not here. // typedef struct _EPVC_ETH_HEADER{ MAC_ADDRESS eh_daddr; MAC_ADDRESS eh_saddr; USHORT eh_type; } EPVC_ETH_HEADER, *PEPVC_ETH_HEADER; // Structure of an ARP header. typedef struct _EPVC_ARP_BODY { USHORT hw; // Hardware address space. = 00 01 USHORT pro; // Protocol address space. = 08 00 UCHAR hlen; // Hardware address length. = 06 UCHAR plen; // Protocol address length. = 04 USHORT opcode; // Opcode. MAC_ADDRESS SenderHwAddr; // Source HW address. IP_ADDR SenderIpAddr; // Source protocol address. MAC_ADDRESS DestHwAddr; // Destination HW address. IP_ADDR DestIPAddr; // Destination protocol address. } EPVC_ARP_BODY, *PEPVC_ARP_BODY; // // Complete Arp Packet // typedef struct _EPVC_ARP_PACKET { // // The first fourteen bytes // EPVC_ETH_HEADER Header; // // The body of the Arp packets // EPVC_ARP_BODY Body; } EPVC_ARP_PACKET, *PEPVC_ARP_PACKET; // // This is the struct that is allocated // by the Rcv Code path if The Rcv packet // is to be copied into a local buffer // typedef struct _EPVC_IP_RCV_BUFFER { // // The Old Head in the Packet that was indicated // to our Rcv Handler // PNDIS_BUFFER pOldHead; // // The Old Tail in the Packet that was indiacated to // our Rcv Hnadler // PNDIS_BUFFER pOldTail; // // The actual Ethernet packet is copied into the // memory below // union { UCHAR Byte[MAX_ETHERNET_FRAME ]; struct { EPVC_ETH_HEADER Eth; // // the ip portion of the packet begins here. // UCHAR ip[1]; }Pkt; } u; } EPVC_IP_RCV_BUFFER, *PEPVC_IP_RCV_BUFFER; //* IP Header format. typedef struct IPHeader { UCHAR iph_verlen; // Version and length. UCHAR iph_tos; // Type of service. USHORT iph_length; // Total length of datagram. USHORT iph_id; // Identification. USHORT iph_offset; // Flags and fragment offset. UCHAR iph_ttl; // Time to live. UCHAR iph_protocol; // Protocol. USHORT iph_xsum; // Header checksum. IPAddr iph_src; // Source address. IPAddr iph_dest; // Destination address. } IPHeader; // // Restore the Pack value to the original // #pragma pack( pop, enter_include1 ) // // The structure all the info required to process // an arp. // typedef struct _EPVC_ARP_CONTEXT { // // Data about the Ndis Packet // BOOLEAN fIsThisAnArp ; BOOLEAN Pad[3]; PNDIS_BUFFER pFirstBuffer ; // // Data about the Current Ndis Buffer // UINT BufferLength ; // // Virtual Addresses'. Pointers to // the Header and the Body of the // Arp Pkt // PEPVC_ARP_PACKET pArpPkt; PEPVC_ETH_HEADER pEthHeader ; PEPVC_ARP_BODY pBody; }EPVC_ARP_CONTEXT, *PEPVC_ARP_CONTEXT; // // This is stored in the Packet Stack and should be of the // size of 2 Ulong_Ptrs // typedef union _EPVC_STACK_CONTEXT { struct { // // 1st containing the Buffer // PNDIS_BUFFER pOldHeadNdisBuffer; } ipv4Send; struct { PEPVC_IP_RCV_BUFFER pIpBuffer; } ipv4Recv; struct { // // Head and tail of the original packet . Used in recv // PNDIS_BUFFER pOldHead; PNDIS_BUFFER pOldTail; }EthLLC; struct { // // Keep track of the last NDIS buffer in original // chain of buffers in a sent packet, when we pad // the end of a runt packet. // PNDIS_BUFFER pOldLastNdisBuffer; }EthernetSend; } EPVC_STACK_CONTEXT, *PEPVC_STACK_CONTEXT; // // Protocol reserved part of the packet, only in case the // packet is allocated by us // typedef struct _EPVC_PKT_CONTEXT { // // Contains the miniport and the old ndis buffer // EPVC_STACK_CONTEXT Stack; // // Original packet which is being repackaged // PNDIS_PACKET pOriginalPacket; }EPVC_PKT_CONTEXT, *PEPVC_PKT_CONTEXT; // // This a struct that tracks a send packets // as it is sent down to physical miniport // typedef struct _EPVC_SEND_STRUCT { // // Old Ndis PAcket // PNDIS_PACKET pOldPacket; // // New Ndis Packet // PNDIS_PACKET pNewPacket; PNDIS_PACKET_STACK pPktStack; // // Are we using the Packet Stack // BOOLEAN fUsingStacks; // // is this an arp packet // BOOLEAN fIsThisAnArp; BOOLEAN fNonUnicastPacket; BOOLEAN fNotIPv4Pkt; // // Old Packet's first NdisBuffer (Head) // PNDIS_BUFFER pHeadOldNdisBuffer; // // Context to be set up in the packet // EPVC_PKT_CONTEXT Context; // // EpvcMiniport // PEPVC_I_MINIPORT pMiniport; } EPVC_SEND_STRUCT , *PEPVC_SEND_STRUCT ; typedef struct _EPVC_SEND_COMPLETE { PNDIS_PACKET_STACK pStack; PNDIS_PACKET pOrigPkt; PNDIS_PACKET pPacket; PEPVC_PKT_CONTEXT pPktContext; BOOLEAN fUsedPktStack ; PEPVC_STACK_CONTEXT pContext; } EPVC_SEND_COMPLETE, *PEPVC_SEND_COMPLETE; typedef struct _EPVC_RCV_STRUCT { // // pPacket that was indicated to us // PNDIS_PACKET pPacket; // // Packet that was allocated by us // PNDIS_PACKET pNewPacket; // // Packet STack, if stacks were used // PNDIS_PACKET_STACK pStack; // // This points to the context for the // Rcv Indication // PEPVC_PKT_CONTEXT pPktContext; // // Tells me if stacks were used // BOOLEAN fUsedPktStacks; // // Tels me if a stack still remains // BOOLEAN fRemaining; // // Was an LLC header a part of the indicated packet // BOOLEAN fLLCHeader; // // Old Packet Status // NDIS_STATUS OldPacketStatus; // // pNew Buffer that is allocated // PNDIS_BUFFER pNewBuffer; // // Start of valid data within the old packet // PUCHAR pStartOfValidData ; // // Number of bytes that were copied // ULONG BytesCopied; // // Contains some ndis buffers and the memory // where packets will be copied into // PEPVC_IP_RCV_BUFFER pIpBuffer; // // Local Memory where the rcvd packet // is copied into . - a part of ip buffer // PUCHAR pLocalMemory; } EPVC_RCV_STRUCT, *PEPVC_RCV_STRUCT; //-------------------------------------------------------------------------------- // // // Structures used by the Protocol and miniport // // These need to declared before the Miniprot and the Protocol Blocks // // // //-------------------------------------------------------------------------------- typedef VOID (*REQUEST_COMPLETION)(PEPVC_NDIS_REQUEST, NDIS_STATUS); // This structure is used when calling NdisRequest. // typedef struct _EPVC_NDIS_REQUEST { NDIS_REQUEST Request; // The NDIS request structure. NDIS_EVENT Event; // Event to signal when done. NDIS_STATUS Status; // Status of completed request. REQUEST_COMPLETION pFunc; // Completion function BOOLEAN fPendedRequest ; // Set to true if a pended request caused this request BOOLEAN fSet; // Was the orig. request a query USHORT Pad; PEPVC_I_MINIPORT pMiniport; } EPVC_NDIS_REQUEST, *PEPVC_NDIS_REQUEST; //------------------------------------------------------------------------------// // Structures used to wrap Ndis Wrapper structures // // // //------------------------------------------------------------------------------// // // The Ndis miniport's wrapper around the Packet Pool // typedef struct _EPVC_PACKET_POOL { ULONG AllocatedPackets; NDIS_HANDLE Handle; } EPVC_PACKET_POOL, *PEPVC_PACKET_POOL; // // The structure that defines the lookaside list used by this miniport // typedef struct _EPVC_NPAGED_LOOKASIDE_LIST { // // The lookaside list structure // NPAGED_LOOKASIDE_LIST List; // // The size of an individual buffer // ULONG Size; // // Outstanding Fragments - Interlocked access only // ULONG OutstandingPackets; // // Verifies if this lookaside list has been allocated // BOOLEAN bIsAllocated; UCHAR Pad[3]; } EPVC_NPAGED_LOOKASIDE_LIST , *PEPVC_NPAGED_LOOKASIDE_LIST ; typedef VOID (*PEVPC_WORK_ITEM_FUNC)( PRM_OBJECT_HEADER, NDIS_STATUS, PRM_STACK_RECORD ); typedef union _EPVC_WORK_ITEM_CONTEXT { struct { // // Oid for the request // NDIS_OID Oid; // // Currently the only data is 1 Dword long // ULONG Data; }Request; }EPVC_WORK_ITEM_CONTEXT, *PEPVC_WORK_ITEM_CONTEXT; typedef struct _EPVC_WORK_ITEM { // // Normal NdisWork Item - Do not move from // the top of this structure // NDIS_WORK_ITEM WorkItem; // // Miniport or Adapter to whom this adapter belongs // PRM_OBJECT_HEADER pParentObj; PEVPC_WORK_ITEM_FUNC pFn; // // Status of async task that was completed // NDIS_STATUS ReturnStatus; } EPVC_WORK_ITEM, *PEPVC_WORK_ITEM; //-------------------------------------------------------------------------------- // // // Tasks used in the Atmepvc driver // // // // // //-------------------------------------------------------------------------------- typedef enum _TASK_CAUSE { TaskCause_Invalid=0, TaskCause_NdisRequest, TaskCause_MediaConnect, TaskCause_MediaDisconnect, TaskCause_MiniportHalt, TaskCause_AfNotify, TaskCause_ProtocolUnbind, TaskCause_AfCloseRequest, TaskCause_ProtocolBind, TaskCause_IncomingClose } TASK_CAUSE, *PTASK_CAUSE; typedef struct { RM_TASK TskHdr; // Used to save the true return status (typically a failure status, // which we don't want to forget during async cleanup). // NDIS_STATUS ReturnStatus; } TASK_ADAPTERINIT, *PTASK_ADAPTERINIT; typedef struct { RM_TASK TskHdr; } TASK_ADAPTERACTIVATE, *PTASK_ADAPTERACTIVATE; typedef struct { RM_TASK TskHdr; NDIS_HANDLE pUnbindContext; TASK_CAUSE Cause; } TASK_ADAPTERSHUTDOWN, *PTASK_ADAPTERSHUTDOWN; typedef struct { RM_TASK TskHdr; NDIS_STATUS ReturnStatus; TASK_CAUSE Cause; PCO_ADDRESS_FAMILY pAf; union { PNDIS_REQUEST pRequest; NDIS_EVENT CompleteEvent; }; } TASK_AF, *PTASK_AF; typedef struct _TASK_VC { RM_TASK TskHdr; NDIS_STATUS ReturnStatus; ULONG FailureState; TASK_CAUSE Cause; ULONG PacketFilter; } TASK_VC, *PTASK_VC; typedef struct _TASK_HALT { RM_TASK TskHdr; NDIS_EVENT CompleteEvent; }TASK_HALT, *PTASK_HALT; typedef struct _TASK_ARP { // // Rm Task associated with the Arp // RM_TASK TskHdr; // // Back pointer to the miniport // PEPVC_I_MINIPORT pMiniport; // // Timer to fire - this does the receive indication // NDIS_MINIPORT_TIMER Timer; // // Arp Packet that will be indicated up. // EPVC_ARP_PACKET Pkt; // // NdisPacket to wrap the ArpPkt // PNDIS_PACKET pNdisPacket; } TASK_ARP, *PTASK_ARP; // // EPVC_TASK is the union of all tasks structures used in atmepvc. // arpAllocateTask allocates memory of sizeof(EPVC_TASK), which is // guaranteed to be large enough to hold any task. // typedef union { RM_TASK TskHdr; TASK_ADAPTERINIT AdapterInit; TASK_ADAPTERACTIVATE AdapterActivate; TASK_ADAPTERSHUTDOWN AdapterShutdown; TASK_AF OpenAf; TASK_HALT MiniportHalt; TASK_ARP Arp; } EPVC_TASK, *PEPVC_TASK; //-------------------------------------------------------------------------------- // // // Epvc Adapter block. // // There is one epvc_adapter per underlying adapter // // // //-------------------------------------------------------------------------------- // // PRIMARY_STATE flags (in Hdr.State) // // PRIMARY_STATE is the primary state of the adapter. // #define EPVC_AD_PS_MASK 0x00f #define EPVC_AD_PS_DEINITED 0x000 #define EPVC_AD_PS_INITED 0x001 #define EPVC_AD_PS_FAILEDINIT 0x002 #define EPVC_AD_PS_INITING 0x003 #define EPVC_AD_PS_REINITING 0x004 #define EPVC_AD_PS_DEINITING 0x005 #define SET_AD_PRIMARY_STATE(_pAD, _IfState) \ RM_SET_STATE(_pAD, EPVC_AD_PS_MASK, _IfState) #define CHECK_AD_PRIMARY_STATE(_pAD, _IfState) \ RM_CHECK_STATE(_pAD, EPVC_AD_PS_MASK, _IfState) #define GET_AD_PRIMARY_STATE(_pAD) \ RM_GET_STATE(_pAD, EPVC_AD_PS_MASK) // // ACTIVE_STATE flags (in Hdr.State) // // ACTIVE_STATE is a secondary state of the adapter. // Primary state takes precedence over secondary sate. For example, // the interface is REINITING and ACTIVE, one should not actively use the // interface. // // NOTE: When the primary state is INITED, the secondary state WILL be // ACTIVATED. It is thus usually only necessary to look at the primary state. // #define EPVC_AD_AS_MASK 0x0f0 #define EPVC_AD_AS_DEACTIVATED 0x000 #define EPVC_AD_AS_ACTIVATED 0x010 #define EPVC_AD_AS_FAILEDACTIVATE 0x020 #define EPVC_AD_AS_DEACTIVATING 0x030 #define EPVC_AD_AS_ACTIVATING 0x040 #define SET_AD_ACTIVE_STATE(_pAD, _IfState) \ RM_SET_STATE(_pAD, EPVC_AD_AS_MASK, _IfState) #define CHECK_AD_ACTIVE_STATE(_pAD, _IfState) \ RM_CHECK_STATE(_pAD, EPVC_AD_AS_MASK, _IfState) #define GET_AD_ACTIVE_STATE(_pAD) \ RM_GET_STATE(_pAD, EPVC_AD_AS_MASK) #define EPVC_AD_INFO_AD_CLOSED 0X10000000 typedef struct _EPVC_ADAPTER { RM_OBJECT_HEADER Hdr; // RM Object header RM_LOCK Lock; // RM Lock // // Flags // ULONG Flags; // // List of instantiated protocols // LIST_ENTRY PtListEntry; // // NDIS bind info. // struct { // Init/Deinit/Reinit task // PRM_TASK pPrimaryTask; // Activate/Deactivate task // PRM_TASK pSecondaryTask; // // Device Name of the adapter // NDIS_STRING DeviceName; NDIS_HANDLE BindingHandle; // To the lower miniport // // Bind Context - used in async completion of // the bind adapter routine // NDIS_HANDLE BindContext; // // pConfig Name - Only to be used in the context of the Bind adapter call. // PNDIS_STRING pEpvcConfigName; // // Copy of the ConfigName // NDIS_STRING EpvcConfigName; // // Device Name - Name of the underlying adapter // PNDIS_STRING pAdapterDeviceName; } bind; struct { CO_ADDRESS_FAMILY AddressFamily; }af; struct { // // Mac Address of the underlying adapter // MAC_ADDRESS MacAddress; // // Max AAL5 PAcket Size - used in determining Lookahead // ULONG MaxAAL5PacketSize; // // Link speed of the ATM adapter. We'll use the same link speed // for the miniport // NDIS_CO_LINK_SPEED LinkSpeed; // // Number of miniports instatiated by this adapter // ULONG NumberOfMiniports; // // MEdia State // default disconnected // NDIS_MEDIA_STATE MediaState; }info; // Group containing local ip addresses, of type EPVC_I_MINIPORT // RM_GROUP MiniportsGroup; }EPVC_ADAPTER, *PEPVC_ADAPTER; //------------------------------------------------------------------------------------ // // // The Epvc ADapter Params is used as a constructor for the adapter block // // It contains all the parameters that are to be initialized in the adapter block // // // //------------------------------------------------------------------------------------ typedef struct _EPVC_ADAPTER_PARAMS { PNDIS_STRING pDeviceName; PNDIS_STRING pEpvcConfigName; NDIS_HANDLE BindContext; }EPVC_ADAPTER_PARAMS, *PEPVC_ADAPTER_PARAMS; //------------------------------------------------------------------------------------ // // // The Epvc Miniports Params is used as a constructor for the miniport block // // It contains all the parameters that are to be initialized in the miniport block // // // //------------------------------------------------------------------------------------ typedef struct _EPVC_I_MINIPORT_PARAMS { PNDIS_STRING pDeviceName; PEPVC_ADAPTER pAdapter; ULONG CurLookAhead ; ULONG NumberOfMiniports; NDIS_CO_LINK_SPEED LinkSpeed; MAC_ADDRESS MacAddress; NDIS_MEDIA_STATE MediaState; }EPVC_I_MINIPORT_PARAMS, *PEPVC_I_MINIPORT_PARAMS ; //-------------------------------------------------------------------------------- // // // Epvc Miniport block. // // // // There is one Miniport structure for each address family // // // //-------------------------------------------------------------------------------- #define fMP_AddressFamilyOpened 0x00000001 #define fMP_DevInstanceInitialized 0x00000010 #define fMP_MiniportInitialized 0x00000020 #define fMP_MiniportCancelInstance 0x00000080 #define fMP_MiniportVcSetup 0x00000100 #define fMP_MakeCallSucceeded 0x00000200 #define fMP_WaitingForHalt 0x00000400 // // Informational flags // #define fMP_InfoClosingCall 0x10000000 #define fMP_InfoCallClosed 0x20000000 #define fMP_InfoMakingCall 0x40000000 #define fMP_InfoHalting 0x80000000 #define fMP_InfoAfClosed 0x01000000 typedef struct _EPVC_I_MINIPORT { RM_OBJECT_HEADER Hdr; // RM Object header RM_LOCK Lock; // RM Lock PEPVC_ADAPTER pAdapter; struct { // // Flags of the address family // ULONG AfFlags; // // Af Handle // NDIS_HANDLE AfHandle; // // Open/Close Miniport Task // PTASK_AF pAfTask; // // Close Address Family Workitem // EPVC_WORK_ITEM CloseAfWorkItem; // // CloseAF RequestTask // PTASK_AF pCloseAfTask; }af; struct { // // Task used in creating/deleting Vcs and Open/Close Make Calls // PTASK_VC pTaskVc; // // Vc Handle // NDIS_HANDLE VcHandle; // // Close Address Family Workitem // NDIS_WORK_ITEM PacketFilterWorkItem; // // New filter // ULONG NewFilter; // // Work item for CloseCall and Delete VC // EPVC_WORK_ITEM CallVcWorkItem; } vc; struct { // // Device Name // NDIS_STRING DeviceName; // // Ndis' context // NDIS_HANDLE MiniportAdapterHandle; // // Lookahead size // ULONG CurLookAhead; }ndis; struct { // // Task to Halt the miniport // PTASK_HALT pTaskHalt; // // Task to Init the miniport // PTASK_HALT pTaskInit; // // Halt Complete Event // NDIS_EVENT HaltCompleteEvent; // // DeInitialize Event used to wait for // InitializeHandler to compelte in // the CancelDevInst code path // NDIS_EVENT DeInitEvent; } pnp; // // Information used to keep state in the miniport // struct { // // Current Packet filter on this miniport instance // ULONG PacketFilter; // // Media State - Connected or disconnected // NDIS_MEDIA_STATE MediaState; // // Mac Address of the miniport // MAC_ADDRESS MacAddressEth; // // Fake Mac Address used in IP encapsulation // MAC_ADDRESS MacAddressDummy; // // Mac Address destination - used in indicating packets // MAC_ADDRESS MacAddressDest; // // Size of the header that will be attached to packets that are sent out // by the miniport // ULONG MaxHeaderLength; // // # of this miniport // ULONG NumberOfMiniports; // // Lookahead length // ULONG CurLookAhead; // // Muticast Info // MAC_ADDRESS McastAddrs[MCAST_LIST_SIZE]; // // Number of MCast addresses present // ULONG McastAddrCount; // // Link Speed of the ATM adapter. We'll use it for our speed as well // ULONG LinkSpeed; // // Indicating Receives // BOOLEAN IndicateRcvComplete; }info; // // Mac Address of the miniport // MAC_ADDRESS MacAddressEth; // // Ethernet Header for incoming packets // EPVC_ETH_HEADER RcvEnetHeader; // // LLC Header, address and length // PUCHAR pLllcHeader; ULONG LlcHeaderLength; // Minimum length of an incoming packet // ULONG MinAcceptablePkt; // Maximum length of an incoming packet // ULONG MaxAcceptablePkt; struct { ULONG vpi; ULONG vci; ULONG MaxPacketSize; USHORT Gap; } config; ULONG Encap; BOOLEAN fAddLLCHeader; BOOLEAN fDoIpEncapsulation; struct { ULONG FramesXmitOk; ULONG FramesRecvOk; ULONG RecvDropped; }count; struct { // // Send and Recv Packet Pools // EPVC_PACKET_POOL Send; EPVC_PACKET_POOL Recv; } PktPool; struct { EPVC_NPAGED_LOOKASIDE_LIST LookasideList; PTASK_ARP pTask; } arps; struct { EPVC_NPAGED_LOOKASIDE_LIST LookasideList; } rcv; // This maintains miniport-wide information relevant to the send path. // struct { // Lock used exclusively for sending. // Protects the following: // ??? this->sendinfo.listPktsWaitingForHeaders // ??? this->sendinfo.NumSendPacketsWaiting // pLocalIp->sendinfo // pDest->sendinfo // // RM_LOCK Lock; // List of send packets waiting for header buffers to become available. // LIST_ENTRY listPktsWaitingForHeaders; // Length of the above list // UINT NumSendPacketsWaiting; } sendinfo; #if 0 // // Temporary stuff // NDIS_HANDLE SendPacketPoolHandle; NDIS_HANDLE RecvPacketPoolHandle; NDIS_STATUS Status; // Open Status NDIS_EVENT Event; // Used by bind/halt for Open/Close Adapter synch. NDIS_MEDIUM Medium; NDIS_REQUEST Request; // This is used to wrap a request coming down // to us. This exploits the fact that requests // are serialized down to us. PULONG BytesNeeded; PULONG BytesReadOrWritten; BOOLEAN IndicateRcvComplete; BOOLEAN OutstandingRequests; //True - if a request has been passed to the miniport below the IM protocol BOOLEAN QueuedRequest; //True - if a request is queued with the IM miniport and needs to be either // failed or sent to the miniport below the IM Protocol BOOLEAN StandingBy; // True - When the miniport or protocol is transitioning from a D0 to Standby (>D0) State // False - At all other times, - Flag is cleared after a transition to D0 NDIS_DEVICE_POWER_STATE MPDeviceState; // Miniport's Device State NDIS_DEVICE_POWER_STATE PTDeviceState; // Protocol's Device State BOOLEAN isSecondary; // Set if miniport is secondary of a bundle NDIS_STRING BundleUniString; // Strores the bundleid PADAPT pPrimaryAdapt; // Pointer to the primary PADAPT pSecondaryAdapt; // Pointer to Secondary's structure KSPIN_LOCK SpinLock; // Spin Lock to protect the global list PADAPT Next; #endif }EPVC_I_MINIPORT, *PEPVC_I_MINIPORT; //-------------------------------------------------------------------------------- // // // Epvc Global Block. // // // // // //-------------------------------------------------------------------------------- typedef struct _EPVC_GLOBALS { RM_OBJECT_HEADER Hdr; RM_LOCK Lock; // Driver global state // struct { // Handle to Driver Object for ATMEPVC // PVOID pDriverObject; // Handle to the single device object representing this driver. // PVOID pDeviceObject; // // Registry path // PUNICODE_STRING pRegistryPath; // // Wrapper Handle // NDIS_HANDLE WrapperHandle; // // Protocol Handle // NDIS_HANDLE ProtocolHandle; // // Driver Handle // NDIS_HANDLE DriverHandle; } driver; struct { RM_GROUP Group; } adapters; struct { NDIS_CLIENT_CHARACTERISTICS CC; }ndis; } EPVC_GLOBALS, *PEPVC_GLOBALS; //-------------------------------------------------------------------------------- // // // Enumerated types . // // // // // //-------------------------------------------------------------------------------- // // This is an enumeration that is used in acquiring locks in a particular order. // If lock A needs to be acquired before lock B, this enumeration will enforce the // order // enum { LOCKLEVEL_GLOBAL=1, // Must start > 0. LOCKLEVEL_ADAPTER, LOCKLEVEL_MINIPORT, LOCKLEVEL_SEND }; // (debug only) Enumeration of types of associations. // enum { EPVC_ASSOC_AD_PRIMARY_TASK, EPVC_ASSOC_ACTDEACT_AD_TASK, EPVC_ASSOC_MINIPORT_OPEN_VC, EPVC_ASSOC_MINIPORT_OPEN_AF, EPVC_ASSOC_MINIPORT_ADAPTER_HANDLE, EPVC_ASSOC_ADAPTER_MEDIA_WORKITEM, EPVC_ASSOC_EXTLINK_PKT_TO_SEND, EPVC_ASSOC_CLOSE_AF_WORKITEM, EPVC_ASSOC_SET_FILTER_WORKITEM, EPVC_ASSOC_EXTLINK_INDICATED_PKT, EPVC_ASSOC_WORKITEM, EPVC_ASSOC_MINIPORT_REQUEST }; enum { IPV4_ENCAP_TYPE, IPV4_LLC_SNAP_ENCAP_TYPE, ETHERNET_ENCAP_TYPE, ETHERNET_LLC_SNAP_ENCAP_TYPE }; //-------------------------------------------------------------------------------- // // // WorkItems // // // // // //-------------------------------------------------------------------------------- typedef struct _EPVC_WORKITEM_MEDIA_EVENT { NDIS_WORK_ITEM WorkItem; NDIS_STATUS State; PEPVC_ADAPTER pAdapter; }EPVC_WORKITEM_MEDIA_EVENT, *PEPVC_WORKITEM_MEDIA_EVENT; typedef union { NDIS_WORK_ITEM WorkItem; EPVC_WORKITEM_MEDIA_EVENT Media; } EPVC_WORKITEM, *PEPVC_WORKITEM; // // Local declarations for reading the registry // typedef struct _MP_REG_ENTRY { NDIS_STRING RegName; // variable name text BOOLEAN bRequired; // 1 -> required, 0 -> optional UINT FieldOffset; // offset to MP_ADAPTER field UINT FieldSize; // size (in bytes) of the field UINT Default; // default value to use UINT Min; // minimum value allowed UINT Max; // maximum value allowed } MP_REG_ENTRY, *PMP_REG_ENTRY; #define NIC_NUM_REG_PARAMS (sizeof (NICRegTable) / sizeof(MP_REG_ENTRY)) #endif // _PRIV_H