windows-xp/Source/XPSP1/NT/net/qos/psched/sys/globals.h

/*++

Copyright (c) 1995-1999  Microsoft Corporation

Module Name:

    globals.h

Abstract:

    global defines and definitions

Author:

    Charlie Wickham (charlwi) 19-Apr-1996

Revision History:

--*/

#ifndef _GLOBALS_
#define _GLOBALS_



//
// Macros 
//

#define IsDeviceStateOn(_a) ((_a)->MPDeviceState == NdisDeviceStateD0 && (_a)->PTDeviceState == NdisDeviceStateD0)


#define IsBestEffortVc(_vc)  (_vc->Flags & GPC_CLIENT_BEST_EFFORT_VC)

#define InitGpcClientVc(x, flags, _adapter)            \
    NdisZeroMemory((x), sizeof(GPC_CLIENT_VC));        \
    (x)->Adapter = (_adapter);                         \
    PS_INIT_SPIN_LOCK(&(x)->Lock);                     \
    (x)->RefCount = 1;                                 \
    (x)->ClVcState = CL_CALL_PENDING;                  \
    (x)->Flags = (flags);                              \
    NdisInitializeEvent(&(x)->GpcEvent);               \


// given a pointer to an NDIS_PACKET, return a pointer to PS' protocol
// context area.
//
#define PS_SEND_PACKET_CONTEXT_FROM_PACKET(_pkt)   \
    ((PPS_SEND_PACKET_CONTEXT)((_pkt)->ProtocolReserved))

#define PS_RECV_PACKET_CONTEXT_FROM_PACKET(_pkt)   \
    ((PPS_RECV_PACKET_CONTEXT)((_pkt)->ProtocolReserved))


#define MIN_PACKET_POOL_SIZE            0x000000FF
#define MAX_PACKET_POOL_SIZE            0x0000FFFF-MIN_PACKET_POOL_SIZE

#define DEFAULT_MAX_OUTSTANDING_SENDS   0xFFFFFFFF     /* Just making sure we don't do DRR by default..*/
#define DEFAULT_ISSLOW_TOKENRATE        8192           /* In Bytes per second = 64 Kbps */
#define DEFAULT_ISSLOW_PACKETSIZE       200            /* In Bytes */
#define DEFAULT_ISSLOW_FRAGMENT_SIZE    100            /* In Bytes */
#define DEFAULT_ISSLOW_LINKSPEED        19200          /* In Bytes  per second = 128 Kbps */

#define PS_IP_SERVICETYPE_CONFORMING_BESTEFFORT_DEFAULT          0
#define PS_IP_SERVICETYPE_CONFORMING_CONTROLLEDLOAD_DEFAULT      0x18
#define PS_IP_SERVICETYPE_CONFORMING_GUARANTEED_DEFAULT          0x28
#define PS_IP_SERVICETYPE_CONFORMING_QUALITATIVE_DEFAULT         0
#define PS_IP_SERVICETYPE_CONFORMING_NETWORK_CONTROL_DEFAULT     0x30
#define PS_IP_SERVICETYPE_CONFORMING_TCPTRAFFIC_DEFAULT          0
#define PS_IP_SERVICETYPE_NONCONFORMING_BESTEFFORT_DEFAULT       0
#define PS_IP_SERVICETYPE_NONCONFORMING_CONTROLLEDLOAD_DEFAULT   0
#define PS_IP_SERVICETYPE_NONCONFORMING_GUARANTEED_DEFAULT       0
#define PS_IP_SERVICETYPE_NONCONFORMING_QUALITATIVE_DEFAULT      0
#define PS_IP_SERVICETYPE_NONCONFORMING_NETWORK_CONTROL_DEFAULT  0
#define PS_IP_SERVICETYPE_NONCONFORMING_TCPTRAFFIC_DEFAULT       0

#define PS_IP_DS_CODEPOINT_MASK                    0x03  //
#define PREC_MAX_VALUE                             0x3f  // Range for the prec value.


#define PS_USER_SERVICETYPE_NONCONFORMING_DEFAULT   1
#define PS_USER_SERVICETYPE_BESTEFFORT_DEFAULT      0
#define PS_USER_SERVICETYPE_CONTROLLEDLOAD_DEFAULT  4
#define PS_USER_SERVICETYPE_GUARANTEED_DEFAULT      5
#define PS_USER_SERVICETYPE_QUALITATIVE_DEFAULT     0
#define PS_USER_SERVICETYPE_NETWORK_CONTROL_DEFAULT 7
#define PS_USER_SERVICETYPE_TCPTRAFFIC_DEFAULT      0
#define USER_PRIORITY_MAX_VALUE                     7 // Range (0-7) for 802.1p

#define WAN_TABLE_INITIAL_SIZE                     16
#define WAN_TABLE_INCREMENT                        32
extern PULONG_PTR     g_WanLinkTable;
extern USHORT         g_NextWanIndex;
extern USHORT         g_WanTableSize;


//  Timer Wheel params  //
extern      ULONG               TimerTag;
extern      ULONG               TsTag;


#define INSTANCE_ID_SIZE                (sizeof(WCHAR) * 20)

//
// the TC-API supports the following service types.
//
// SERVICETYPE_BESTEFFORT
// SERVICETYPE_NETWORK_CONTROL
// SERVICETYPE_QUALITATIVE
// SERVICETYPE_CONTROLLEDLOAD
// SERVICETYPE_GUARANTEED
// SERVICETYPE_NONCONFORMING 
//

#define NUM_TC_SERVICETYPES                        6
//
// These are the states for the GPC client's VCs. We need to keep a fair 
// amount of state because we can get closes from the call manager below us, 
// from an unbind, or from the GPC.
//

typedef enum _CL_VC_STATE {
    CL_VC_INITIALIZED = 1,
    CL_CALL_PENDING,
    CL_INTERNAL_CALL_COMPLETE,
    CL_CALL_COMPLETE,
    CL_MODIFY_PENDING,
    CL_GPC_CLOSE_PENDING,
    CL_INTERNAL_CLOSE_PENDING
} CL_VC_STATE;

typedef enum _PS_DEVICE_STATE {
    PS_DEVICE_STATE_READY = 0,
    PS_DEVICE_STATE_ADDING,
    PS_DEVICE_STATE_DELETING
} PS_DEVICE_STATE;


extern  ULONG   CreateDeviceMutex;

//
// Simple Mutual Exclusion constructs used in preference to
// using KeXXX calls since we don't have Mutex calls in NDIS.
// These can only be called at passive IRQL.
//

#define MUX_ACQUIRE_MUTEX(_pMutexCounter)                               \
{                                                                       \
    while (NdisInterlockedIncrement(_pMutexCounter) != 1)               \
    {                                                                   \
        NdisInterlockedDecrement(_pMutexCounter);                       \
        NdisMSleep(10000);                                              \
    }                                                                   \
}

#define MUX_RELEASE_MUTEX(_pMutexCounter)                               \
{                                                                       \
    NdisInterlockedDecrement(_pMutexCounter);                           \
}


//
// CL_VC_STATE is further modified by these flags.
//

// Indicates that the GPC has requested a close, 
// which we will need to complete.

// COMPLETE_GPC_CLOSE      : GPC has requested a close which we will need to 
//                           complete. 
// INTERNAL_CLOSE_REQUESTED: Indicates that an internal close has been 
//                           requested and should be processed upon completion
//                           of the call.

#define GPC_CLOSE_REQUESTED        0x00000001   
#define INTERNAL_CLOSE_REQUESTED   0x00000002   
#define GPC_CLIENT_BEST_EFFORT_VC  0x00000008
#define GPC_MODIFY_REQUESTED       0x00000010  
#define GPC_WANLINK_VC             0x00000020
#define GPC_ISSLOW_FLOW            0x00000040


//
// These are the states for the BE Vc. In addition to keeping the standard
// CL Vc states for this Vc, we also keep some specific state. The BE Vc
// is initially BE_VC_INITIALIZED. It becomes BE_VC_RUNNING after it has 
// successfully been opened. When it is time to shut down the BE Vc, it 
// goes to BE_VC_CLOSING if there are no pending packets, or to 
// BE_WAITING_FOR_PENDING_PACKETS, if there are pending packets.
//

extern PUCHAR GpcVcState[];

//
// The best effort VC structure for each adapter is contained in 
// the adapter structure. Also - each vc points to the adapter 
// with which it is associated. Therefore, pointers to best-effort 
// VCs can be identified beause they are the same address as the
// offset of the best-effort VC in the adapter struct with which
// they are associated.
//


//
// current state of PS's MP device
//
typedef enum _ADAPTER_STATE {
    AdapterStateInitializing = 1,
    AdapterStateRunning,
    AdapterStateWaiting,
    AdapterStateDisabled,
    AdapterStateClosing,
    AdapterStateClosed
} ADAPTER_STATE;

typedef enum _DRIVER_STATE {
    DriverStateLoaded = 1,
    DriverStateUnloading,
    DriverStateUnloaded
} DRIVER_STATE;

typedef enum _ADAPTER_MODE {
    AdapterModeDiffservFlow = 1,
    AdapterModeRsvpFlow
} ADAPTER_MODE;

//
// shutdown mask values
//

#define SHUTDOWN_CLOSE_WAN_ADDR_FAMILY       0x00000002   // Per adapter
#define SHUTDOWN_DELETE_PIPE                 0x00000008   // Per adapter
#define SHUTDOWN_FREE_PS_CONTEXT             0x00000010   // Per adapter
#define SHUTDOWN_UNBIND_CALLED               0x00000020   // Per adapter
#define SHUTDOWN_MPHALT_CALLED               0x00000040   // Per adapter
#define SHUTDOWN_CLEANUP_ADAPTER             0x00000080   // Per adapter
#define SHUTDOWN_PROTOCOL_UNLOAD             0x00000100   // Per adapter
#define SHUTDOWN_BIND_CALLED                 0x00000200   // Per adapter
#define SHUTDOWN_MPINIT_CALLED               0x00000400   // per adapter

#define SHUTDOWN_RELEASE_TIMERQ         0x00010000
#define SHUTDOWN_DEREGISTER_PROTOCOL    0x00040000
#define SHUTDOWN_DELETE_DEVICE          0x00080000
#define SHUTDOWN_DELETE_SYMLINK         0x00100000
#define SHUTDOWN_DEREGISTER_GPC         0x00200000
#define SHUTDOWN_DEREGISTER_MINIPORT    0x00400000

#define LOCKED 0
#define UNLOCKED 1

#define NEW_VC 0
#define MODIFY_VC 1


//
// QOS related
//

#define QOS_UNSPECIFIED (ULONG)-1

//
// bandwidth related
//

#define UNSPECIFIED_RATE                -1 // indefinite bandwidth
#define RESERVABLE_FRACTION         80 // percentage of link speed

//
// state flags for WAN AF bindings
//

#define WAN_ADDR_FAMILY_OPEN            0x00000001

//
// types of VCs. Note that dummy VCs are created to represent WAN links.
// This allows them to be registered with WMI. They are differentiated by
// the VC type.
//

#define VC_FLOW         1
#define VC_WAN_INTFC    2

typedef struct _PS_SPIN_LOCK 
{
    NDIS_SPIN_LOCK Lock;
#if DBG
    LONG  LockAcquired;
    UCHAR LastAcquiredFile[8];
    ULONG LastAcquiredLine;
    UCHAR LastReleasedFile[8];
    ULONG LastReleasedLine;
#endif
} PS_SPIN_LOCK, *PPS_SPIN_LOCK;



#define BEVC_LIST_LEN   3       //  We have these many BEVCs to do DRR.
#define PORT_LIST_LEN   1       //  Each BEVC will store upto these many port numbers.



typedef struct _GPC_CLIENT_VC {

    //
    // LLTag - for tracking allocation from and freeing to LL list.
    //
    // Lock
    //
    // RefCount
    //
    //
    // Linkage - to put on the adapter block list
    //
    // ClVcState
    //
    // Flags - further modify state
    //
    // AdapterBlk - pointer to associated ADAPTER_BLK context
    //
    // CfInfoHandle - handle to CfInfo
    //
    // InstanceName - copy of instance name registered with WMI for this flow
    //
    // CfType - GPC classification family associated with this VC
    //
    // VcHandle - handle to VC created for this flow
    //
    // CallParameters - pointer to call parameters saved while a MakeCall or
    //                  ModifyCallQoS is in progress
    //
    // AdapterStats - pointer to the Adapter Stats (for non WAN links) or 
    //                per WAN stats.

    STRUCT_LLTAG;
    ULONG                   RefCount;
    CL_VC_STATE             ClVcState;
    struct _ADAPTER         *Adapter;
    ULONG                   Flags;
    PS_SPIN_LOCK            Lock;

    LIST_ENTRY              Linkage;
    NDIS_STRING             InstanceName;

    UCHAR                   IPPrecedenceNonConforming;
    UCHAR                   UserPriorityConforming;
    UCHAR                   UserPriorityNonConforming;
    GPC_HANDLE              CfInfoHandle;
    PCF_INFO_QOS            CfInfoQoS;
    PCF_INFO_QOS            ModifyCfInfoQoS;
    GPC_HANDLE              CfType;
    NDIS_HANDLE             NdisWanVcHandle;
    PCO_CALL_PARAMETERS     CallParameters;
    PCO_CALL_PARAMETERS     ModifyCallParameters;
    PPS_ADAPTER_STATS       AdapterStats;
    struct _PS_WAN_LINK     *WanLink;

    //
    // For the Scheduling Components
    //
    PPS_FLOW_CONTEXT        PsFlowContext;
    PS_FLOW_STATS           Stats;
    ULONG                   TokenRateChange;
    ULONG                   RemainingBandwidthIncreased;
    ULONG                   ShapeTokenRate;
    ULONG                   ISSLOWFragmentSize;

    //
    // These are used to optmize the send path. Over non Wan links, these point to
    // Adapter->PsComponent and Adapter->PsPipeContext. Over WanLinks, these point
    // to WanLink->PsComponent and WanLink->PspipeContext.
    //
    PPSI_INFO               PsComponent;
    PPS_PIPE_CONTEXT        PsPipeContext;
    PSU_SEND_COMPLETE       SendComplete;
    PPS_PIPE_CONTEXT        SendCompletePipeContext;
    NDIS_EVENT              GpcEvent;

    //
    //  This flag is added to indicate whether the RemoveFlow() should be called upon ref-count=0 
    //
    BOOL                    bRemoveFlow;

    //  We'll hold on to flows in this array    //
    USHORT                  SrcPort[PORT_LIST_LEN];
    USHORT                  DstPort[PORT_LIST_LEN];
    USHORT                  NextSlot;

} GPC_CLIENT_VC, *PGPC_CLIENT_VC;


typedef struct _DIFFSERV_MAPPING {
    PGPC_CLIENT_VC   Vc;
    UCHAR            ConformingOutboundDSField;
    UCHAR            NonConformingOutboundDSField;
    UCHAR            ConformingUserPriority;
    UCHAR            NonConformingUserPriority;
} DIFFSERV_MAPPING, *PDIFFSERV_MAPPING;


typedef struct _ADAPTER {

    LIST_ENTRY Linkage;

    //
    // MpDeviceName, UpperBinding - unicode device names for 
    // the underlying MP device and the UpperBinding exposed. 
    // The buffers for the strings are allocated with the 
    // adapter and need to be freed with it.
    //
    // ShutdownMask - mask of operations to perform during 
    // unbinding from lower MP
    //

    PS_SPIN_LOCK Lock;
    REF_CNT RefCount;

    NDIS_STRING MpDeviceName;
    NDIS_STRING UpperBinding;
    NDIS_STRING WMIInstanceName;
    NDIS_STRING ProfileName;

    // Points to the "psched\parameter\adapter\...\"
    NDIS_STRING RegistryPath;


    ULONG ShutdownMask;
    PNETWORK_ADDRESS_LIST IpNetAddressList;
    PNETWORK_ADDRESS_LIST IpxNetAddressList;

    //
    // PsMpState - init'ing, running, or closing
    //
    // PsNdisHandle - the handle that identifies the PS device to NDIS
    //
    // BlockingEvent - used to synchronize execution of functions that are
    // awaiting completion
    //
    // FinalStatus - holds status returned in completion routine
    //
    // SendBlockPool    - Pool Handle for per-packet info in the send path
    // SendPacketPool   - Pool handle for NDIS packets in the send path. 
    // RecvPacketPool   - Pool handle for NDIS packets in the recv path. 
    //
    // RawLinkSpeed - link speed as determined by OID_GEN_LINK_SPEED,
    // in 100 bps units.
    //
    // BestEffortLimit - Bps for internal best effort VC; 
    //
    // NonBestEffortLimit - Bps for total non best effort flows;
    //
    // ReservationLimitValue - The % of bandwidth that has to be used for non b/e flows.
    //
    // BestEffortVc - internal best effort VC struct
    //
    // BestEffortVcCreated - set after the VC has been created
    //
    // WanLinkList - list of WAN links on the underlying NDISWAN
    //

    ADAPTER_STATE PsMpState;
    NDIS_HANDLE PsNdisHandle;
    NDIS_EVENT BlockingEvent;
    NDIS_EVENT RefEvent;
    NDIS_EVENT MpInitializeEvent;
    NDIS_EVENT LocalRequestEvent;
    NDIS_STATUS FinalStatus;
    NDIS_HANDLE  SendPacketPool;
    NDIS_HANDLE  RecvPacketPool;
    NDIS_HANDLE  SendBlockPool;  
    ULONG RawLinkSpeed;
    ULONG BestEffortLimit;
    ULONG NonBestEffortLimit;
    ULONG ReservationLimitValue;
    GPC_CLIENT_VC BestEffortVc;
    LIST_ENTRY WanLinkList;

    
    //
    // Scheduler info:
    //
    // PSComponent - pointer to info first scheduling component
    //
    // PSPipeContext - scheduling component's context area for pipe
    //
    // BestEffortPSFlowContext - scheduling component's context area 
    //  for best effort VC
    //
    // FlowContextLength - length of flow context area for scheduler
    //
    // PacketContextLength - length of packet context area
    //
    // SendComplete - scheduler's send completion routine
    //

    PPSI_INFO PsComponent;
    PPS_PIPE_CONTEXT PsPipeContext;
    ULONG PipeContextLength;
    BOOLEAN PipeHasResources;
    ULONG FlowContextLength;
    ULONG PacketContextLength;
    ULONG ClassMapContextLength;

    //
    // Underlying adapter info - handle, type, etc.
    // LowerMPHandle - the binding handle to the underlying MP
    // BindContext - used in BindAdapterHandler 
    // MediaType - self explanatory I would hope
    // LinkSpeed - in 100 bits/sec
    // TotalSize - max # of bytes including the header.
    // RemainingBandWidth - amount of schedulable bytes/second left on this adapter
    // PipeFlags - copy of flags parameter handed to scheduler during pipe initialization
    // HeaderSize - number of bytes in MAC header for this adapter
    // IPHeaderOffset - offset of the IP header - This could be different from HeaderSize because
    //                  the transport could add a LLC/SNAP header.
    // Stats - per adapter stats counters
    // SDModeControlledLoad - Default handling for non-conforming controlled load traffic
    // SDModeGuaranteed - Default handling for non-conforming guaranteed service traffic
    // MaxOutstandingSends - Maximum number of outstanding sends allowed

    NDIS_HANDLE LowerMpHandle;
    NDIS_MEDIUM MediaType;
    NDIS_HANDLE BindContext;
    ULONG LinkSpeed;
    ULONG TotalSize;
    ULONG RemainingBandWidth;
    ULONG PipeFlags;
    ULONG HeaderSize;
    ULONG IPHeaderOffset;
    PS_ADAPTER_STATS Stats;
    ULONG SDModeControlledLoad;
    ULONG SDModeGuaranteed;
    ULONG SDModeNetworkControl;
    ULONG SDModeQualitative;
    ULONG MaxOutstandingSends;

    //
    // WanCmHandle - handle to the WAN call manager, as returned from 
    //              NdisClOpenAddressFamily.
    //

    NDIS_HANDLE WanCmHandle;

    //
    // WanBindingState - state of WAN call manager binding

    ULONG WanBindingState;

    UCHAR IPServiceTypeBestEffort;
    UCHAR IPServiceTypeControlledLoad;
    UCHAR IPServiceTypeGuaranteed;
    UCHAR IPServiceTypeNetworkControl;
    UCHAR IPServiceTypeQualitative;
    UCHAR IPServiceTypeTcpTraffic;
    UCHAR IPServiceTypeBestEffortNC;
    UCHAR IPServiceTypeControlledLoadNC;
    UCHAR IPServiceTypeGuaranteedNC;
    UCHAR IPServiceTypeNetworkControlNC;
    UCHAR IPServiceTypeQualitativeNC;
    UCHAR IPServiceTypeTcpTrafficNC;

    UCHAR UserServiceTypeNonConforming;
    UCHAR UserServiceTypeBestEffort;
    UCHAR UserServiceTypeControlledLoad;
    UCHAR UserServiceTypeGuaranteed;
    UCHAR UserServiceTypeNetworkControl;
    UCHAR UserServiceTypeQualitative;
    UCHAR UserServiceTypeTcpTraffic;

    //
    // No of CfInfos - In the send path, this is used to determine whether we 
    // have to classify the packet or send it over the b/e VC
    //
    ULONG CfInfosInstalled;
    ULONG FlowsInstalled;
    LIST_ENTRY GpcClientVcList;
    ULONG WanLinkCount;

    LARGE_INTEGER VcIndex;

#if DBG
    ULONG GpcNotifyPending;
#endif
    PDIFFSERV_MAPPING pDiffServMapping;
    ADAPTER_MODE AdapterMode;
    ULONG ISSLOWTokenRate;
    ULONG ISSLOWPacketSize;
    ULONG ISSLOWFragmentSize;
    ULONG ISSLOWLinkSpeed;
    BOOLEAN IndicateRcvComplete;
    BOOLEAN IfcNotification;
    BOOLEAN StandingBy;
    ULONG OutstandingNdisRequests;
    NDIS_DEVICE_POWER_STATE MPDeviceState;
    NDIS_DEVICE_POWER_STATE PTDeviceState;
    USHORT ProtocolType;
    struct _PS_NDIS_REQUEST *PendedNdisRequest;
    TC_INTERFACE_ID InterfaceID;

} ADAPTER, *PADAPTER;



//
// Wan links are created when we get a WAN_LINE_UP from an underlying 
// NDISWAN. There may be multiple WAN links per adapter. Each WAN link
// has a single best-effort VC on it and may have any number of additional 
// VCs (one per flow).
//

//
// WAN VC - describes a VC associated with this WAN link
//

typedef enum _WAN_STATE {
    WanStateOpen = 1,
    WanStateClosing
} WAN_STATE;

typedef struct _PS_WAN_LINK 
{
    WAN_STATE               State;
    LIST_ENTRY              Linkage;
    ULONG                   RawLinkSpeed;     // In 100 bps
    ULONG                   LinkSpeed;        // In Bps (Bytes per second)
    UCHAR                   OriginalLocalMacAddress[ARP_802_ADDR_LENGTH];
    UCHAR                   OriginalRemoteMacAddress[ARP_802_ADDR_LENGTH];
    REF_CNT                 RefCount;
    DIAL_USAGE              DialUsage;
    USHORT                  ProtocolType;
    ULONG                   LocalIpAddress;
    ULONG                   RemoteIpAddress;
    ULONG                   LocalIpxAddress;
    ULONG                   RemoteIpxAddress;
    PS_ADAPTER_STATS        Stats;
    PS_SPIN_LOCK            Lock;
    ULONG                   FlowsInstalled;
    NDIS_STRING             InstanceName;
    NDIS_STRING             MpDeviceName;
    PADAPTER                Adapter;
    ULONG                   RemainingBandWidth;
    ULONG                   NonBestEffortLimit;
    PPSI_INFO               PsComponent;
    PPS_PIPE_CONTEXT        PsPipeContext;
    ULONG                   ShutdownMask;
    USHORT                  UniqueIndex;
    ETH_HEADER              SendHeader;
    ETH_HEADER              RecvHeader;
    ADAPTER_MODE            AdapterMode;
    PDIFFSERV_MAPPING       pDiffServMapping;
    ULONG                   CfInfosInstalled;
    TC_INTERFACE_ID         InterfaceID;

    GPC_CLIENT_VC           BestEffortVc;
    GPC_CLIENT_VC           BeVcList[ BEVC_LIST_LEN ];
    int                     NextVc;
    

} PS_WAN_LINK, *PPS_WAN_LINK;
    
//
// our NdisRequest super structure. There are two types of NdisRequests: 
// originated by the upper layer which go straight through to the 
// underlying miniport and originated by the PS. The latter also 
// degenerates into blocking and nonblocking.
//
// Since upper layer NdisRequests are unbundled to MPs, we need to 
// allocate our own structure to rebuild and issue the request to 
// the lower layer. We need some addt'l space to hold pointers to the 
// BytesWritten/BytesRead and BytesNeeded parameters of the original 
// request. These are tagged on at the end so the NdisRequest completion 
// routine can set those values in the NdisRequest originally issued to PS.
//
// There are allocated by NdisAllocateFromNPagedLookasideList, there is a STRUCT_LLTAG.
// LocalRequest means the request was issued by PS and shouldn't be 
// completed to the higher layer. If a LocalCompletion routine is specified, 
// then this is a nonblocking request.
//
// OriginalNdisRequest is used to complete a higher layer CoRequest.
//

typedef VOID (*LOCAL_NDISREQUEST_COMPLETION_FUNCTION)(PADAPTER,
                                                      NDIS_STATUS);
typedef struct _PS_NDIS_REQUEST {
    NDIS_REQUEST ReqBuffer; // Must be first!!!
    STRUCT_LLTAG;
    PULONG BytesReadOrWritten;
    PULONG BytesNeeded;
    BOOLEAN LocalRequest;
    LOCAL_NDISREQUEST_COMPLETION_FUNCTION LocalCompletionFunc;
} PS_NDIS_REQUEST, *PPS_NDIS_REQUEST;


//
// use Generic NdisRequest types to indicate NdisRequests that 
// were originated by PS
//

#define NdisRequestLocalSetInfo     NdisRequestGeneric1
#define NdisRequestLocalQueryInfo   NdisRequestGeneric2

//
// Packet context structure. This area resides at the start of 
// the ProtocolReserved area of each packet
//
// Info - packet info block for this packet. Includes information 
//      potentially needed by the scheduling components: queue links, 
//      conformance time, packet length.
//
// AdapterVCLink - links packet on Adapter VC's list of outstanding 
//      packets. Once a packet is removed from the timer Q for sending, 
//      it is also removed from this list. This list is used to free 
//      packets that are awaiting transmission when the adapter VC is 
//      deactivate. Packets in the process of being transmitted
//      aren't linked since a reference was taken out for each packet 
//      associated with the adapter VC.
//
// The following vars are used only during the sending of a packet:
//
// OriginalPacket - a pointer to the original packet (duh) handed to us by
//      the upper layer.
//
// AdapterVC - pointer back to AdapterVC struct. Used during send completion so
//      completion is propagated to higher layer in the correct manner
//
// SchedulingComponentInfo - Any packet context area required by the scheduling
//     components is stored after the PS's packet context.  If none of the
//     components need additional context area, then this area is not included.
//
// MediaSpecificInfo - used to hold packet priority for MPs that allow packet
//     priority to be specified. Included in the proto reserved area only if
//     the lower MP supports priority queueing. Immediately follows the 
//     packet context struct if included
//
// SubmittedToScheduler - some packets bypass the scheduler. These should not 
//     be submitted to the scheduler's completion routine.
//

typedef struct _PS_SEND_PACKET_CONTEXT
{
    PACKET_INFO_BLOCK Info;
    PNDIS_PACKET      OriginalPacket;
    SINGLE_LIST_ENTRY FreeList;
    PGPC_CLIENT_VC    Vc;
} PS_SEND_PACKET_CONTEXT, *PPS_SEND_PACKET_CONTEXT;

typedef struct _PS_RECV_PACKET_CONTEXT
{
    PNDIS_PACKET OriginalPacket;
} PS_RECV_PACKET_CONTEXT, *PPS_RECV_PACKET_CONTEXT;

// 
//  Ndis requires a minimum of 8 bytes for the MediaSpecific parameters.
//  We'll create a dummy media specific parmeter block:
//

typedef struct _PS_MEDIA_PARAMETERS{

    CO_MEDIA_PARAMETERS StdMediaParameters;
    UCHAR LinkId[6]; // Used by NdisWan
    NDIS_STRING InstanceName; 

} PS_MEDIA_PARAMETERS, *PPS_MEDIA_PARAMETERS;


typedef struct _RUNNING_AVERAGE {
    ULONG *Elements;
    ULONG Index;
    ULONG Sum;
    ULONG Size;    
} RUNNING_AVERAGE, *PRUNNING_AVERAGE;

#if CBQ
//
// Context used by AddCfInfo for "ClassMap" to be sent back 
// to the GPC. 
//
typedef struct _CLASS_MAP_CONTEXT_BLK {
    PADAPTER Adapter;
    PPS_CLASS_MAP_CONTEXT ComponentContext;
    PPS_WAN_LINK WanLink;
} CLASS_MAP_CONTEXT_BLK, *PCLASS_MAP_CONTEXT_BLK;
#endif

typedef struct _PS_INTERFACE_INDEX {
    PADAPTER     Adapter;
    PPS_WAN_LINK WanLink;
} PS_INTERFACE_INDEX_CONTEXT, *PPS_INTERFACE_INDEX_CONTEXT;

//
// define for determing if media is LAN oriented
//

#define NDIS_MEDIA_LAN( _adpt ) (( _adpt )->MediaType == NdisMedium802_3 || \
                                 ( _adpt )->MediaType == NdisMedium802_5 || \
                                 ( _adpt )->MediaType == NdisMediumFddi || \
                                 ( _adpt )->MediaType == NdisMediumDix)



//
// global vars (not based on a device instance)
//

extern ULONG                  InitShutdownMask;
extern ULONG                  AdapterCount;
extern ULONG                  DriverRefCount;
extern BOOLEAN                WMIInitialized;
extern DRIVER_STATE           gDriverState;
extern LIST_ENTRY             AdapterList;
extern LIST_ENTRY             PsComponentList;
extern LIST_ENTRY             PsProfileList;
extern NDIS_HANDLE            ClientProtocolHandle;
extern NDIS_HANDLE            CallMgrProtocolHandle;
extern NDIS_HANDLE            MpWrapperHandle;
extern NDIS_HANDLE            LmDriverHandle;
extern NDIS_HANDLE            PsDeviceHandle;
extern PDRIVER_OBJECT         PsDriverObject;
extern PDEVICE_OBJECT         PsDeviceObject;
extern HANDLE                 PsDeviceHandle;
extern NPAGED_LOOKASIDE_LIST  NdisRequestLL;
extern NPAGED_LOOKASIDE_LIST  AdapterVcLL;
extern NPAGED_LOOKASIDE_LIST  ClientVcLL;
extern NPAGED_LOOKASIDE_LIST  GpcClientVcLL;
extern NDIS_EVENT             DriverUnloadEvent;

extern NDIS_STRING            PsDriverName;
extern NDIS_STRING            PsSymbolicName;
extern NDIS_STRING            PsMpName;
extern NDIS_STRING            WanPrefix;
extern NDIS_STRING            VcPrefix;
extern NDIS_STRING            MachineRegistryKey;

extern PSI_INFO               TbConformerInfo;
extern PSI_INFO               ShaperInfo;
extern PSI_INFO               DrrSequencerInfo;
extern PSI_INFO               SchedulerStubInfo;
extern PSI_INFO               TimeStmpInfo;

extern PS_PROFILE             DefaultSchedulerConfig;

extern PS_PROCS               PsProcs;

extern ULONG                  gEnableAvgStats;
extern ULONG                  gEnableWindowAdjustment;
extern NDIS_STRING            gsEnableWindowAdjustment;

// Global locks

extern PS_SPIN_LOCK AdapterListLock;
extern PS_SPIN_LOCK PsComponentListLock;
extern PS_SPIN_LOCK PsProfileLock;
extern PS_SPIN_LOCK DriverUnloadLock;
    
// Timer

extern ULONG gTimerResolutionActualTime;
extern ULONG gTimerSet;

//
// ZAW
//
extern NDIS_EVENT gZAWEvent;
extern ULONG      gZAWState;
#define ZAW_STATE_READY  0
#define ZAW_STATE_IN_USE 1

// GPC Interface

#define PS_QOS_CF       0x00000001
#define PS_CLASS_MAP_CF 0x00000002
#define GPC_NO_MATCH (ULONG)-1

extern GPC_EXPORTED_CALLS GpcEntries;
extern GPC_HANDLE GpcQosClientHandle;
#if CBQ
extern GPC_HANDLE GpcClassMapClientHandle;
#endif
extern PS_DEVICE_STATE DeviceState;

extern PDRIVER_DISPATCH DispatchTable[IRP_MJ_MAXIMUM_FUNCTION];

//
// NULL Component hacks for now [ShreeM]
//
extern PS_RECEIVE_PACKET       TimeStmpRecvPacket;
extern PS_RECEIVE_INDICATION   TimeStmpRecvIndication;

extern BOOLEAN  TimeStmpReceivePacket();

//
//  This is the RawLinkSpeed below which we trigger DRR
//
#define MAX_LINK_SPEED_FOR_DRR      7075 //( 56.6 * 1000 / 8)  // 56.6 kbps converted to bytes/sec


#endif/* _GLOBALS_ */

/* end globals.h */