diff options
Diffstat (limited to 'drivers/staging/bcm/cntrl_SignalingInterface.h')
| -rw-r--r-- | drivers/staging/bcm/cntrl_SignalingInterface.h | 677 |
1 files changed, 677 insertions, 0 deletions
diff --git a/drivers/staging/bcm/cntrl_SignalingInterface.h b/drivers/staging/bcm/cntrl_SignalingInterface.h new file mode 100644 index 0000000..4cbe300 --- /dev/null +++ b/drivers/staging/bcm/cntrl_SignalingInterface.h @@ -0,0 +1,677 @@ +#ifndef CNTRL_SIGNALING_INTERFACE_ +#define CNTRL_SIGNALING_INTERFACE_ + + +#ifdef BECEEM_TARGET + +#include <mac_common.h> +#include <msg_Dsa.h> +#include <msg_Dsc.h> +#include <msg_Dsd.h> +#include <sch_definitions.h> +using namespace Beceem; +#ifdef ENABLE_CORRIGENDUM2_UPDATE +extern B_UINT32 g_u32Corr2MacFlags; +#endif + +#else + + +#define DSA_REQ 11 +#define DSA_RSP 12 +#define DSA_ACK 13 +#define DSC_REQ 14 +#define DSC_RSP 15 +#define DSC_ACK 16 +#define DSD_REQ 17 +#define DSD_RSP 18 +#define DSD_ACK 19 +#define MAX_CLASSIFIERS_IN_SF 4 + +#endif + +#define MAX_STRING_LEN 20 +#define MAX_PHS_LENGTHS 255 +#define VENDOR_PHS_PARAM_LENGTH 10 +#define MAX_NUM_ACTIVE_BS 10 +#define AUTH_TOKEN_LENGTH 10 +#define NUM_HARQ_CHANNELS 16 //Changed from 10 to 16 to accomodate all HARQ channels +#define VENDOR_CLASSIFIER_PARAM_LENGTH 1 //Changed the size to 1 byte since we dnt use it +#define VENDOR_SPECIF_QOS_PARAM 1 +#define VENDOR_PHS_PARAM_LENGTH 10 +#define MBS_CONTENTS_ID_LENGTH 10 +#define GLOBAL_SF_CLASSNAME_LENGTH 6 + +#define TYPE_OF_SERVICE_LENGTH 3 +#define IP_MASKED_SRC_ADDRESS_LENGTH 32 +#define IP_MASKED_DEST_ADDRESS_LENGTH 32 +#define PROTOCOL_SRC_PORT_RANGE_LENGTH 4 +#define PROTOCOL_DEST_PORT_RANGE_LENGTH 4 +#define ETHERNET_DEST_MAC_ADDR_LENGTH 12 +#define ETHERNET_SRC_MAC_ADDR_LENGTH 12 +#define NUM_ETHERTYPE_BYTES 3 +#define NUM_IPV6_FLOWLABLE_BYTES 3 + + +//////////////////////////////////////////////////////////////////////////////// +////////////////////////structure Definitions/////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +/// \brief class cCPacketClassificationRule +#ifdef BECEEM_TARGET +class CCPacketClassificationRuleSI{ + public: + /// \brief Constructor for the class + CCPacketClassificationRuleSI(): + u8ClassifierRulePriority(mClassifierRulePriority), + u8IPTypeOfServiceLength(mIPTypeOfService), + u8Protocol(mProtocol), + u8IPMaskedSourceAddressLength(0), + u8IPDestinationAddressLength(0), + u8ProtocolSourcePortRangeLength(0), + u8ProtocolDestPortRangeLength(0), + u8EthernetDestMacAddressLength(0), + u8EthernetSourceMACAddressLength(0), + u8EthertypeLength(0), + u16UserPriority(mUserPriority), + u16VLANID(mVLANID), + u8AssociatedPHSI(mAssociatedPHSI), + u16PacketClassificationRuleIndex(mPacketClassifierRuleIndex), + u8VendorSpecificClassifierParamLength(mVendorSpecificClassifierParamLength), + u8IPv6FlowLableLength(mIPv6FlowLableLength), + u8ClassifierActionRule(mClassifierActionRule) + + {} + void Reset() + { + CCPacketClassificationRuleSI(); + } +#else +struct _stCPacketClassificationRuleSI{ +#endif + + /** 16bit UserPriority Of The Service Flow*/ + B_UINT16 u16UserPriority; + /** 16bit VLANID Of The Service Flow*/ + B_UINT16 u16VLANID; + /** 16bit Packet Classification RuleIndex Of The Service Flow*/ + B_UINT16 u16PacketClassificationRuleIndex; + /** 8bit Classifier Rule Priority Of The Service Flow*/ + B_UINT8 u8ClassifierRulePriority; + /** Length of IP TypeOfService field*/ + B_UINT8 u8IPTypeOfServiceLength; + /** 3bytes IP TypeOfService */ + B_UINT8 u8IPTypeOfService[TYPE_OF_SERVICE_LENGTH]; + /** Protocol used in classification of Service Flow*/ + B_UINT8 u8Protocol; + /** Length of IP Masked Source Address */ + B_UINT8 u8IPMaskedSourceAddressLength; + /** IP Masked Source Address used in classification for the Service Flow*/ + B_UINT8 u8IPMaskedSourceAddress[IP_MASKED_SRC_ADDRESS_LENGTH]; + /** Length of IP Destination Address */ + B_UINT8 u8IPDestinationAddressLength; + /** IP Destination Address used in classification for the Service Flow*/ + B_UINT8 u8IPDestinationAddress[IP_MASKED_DEST_ADDRESS_LENGTH]; + /** Length of Protocol Source Port Range */ + B_UINT8 u8ProtocolSourcePortRangeLength; + /** Protocol Source Port Range used in the Service Flow*/ + B_UINT8 u8ProtocolSourcePortRange[PROTOCOL_SRC_PORT_RANGE_LENGTH]; + /** Length of Protocol Dest Port Range */ + B_UINT8 u8ProtocolDestPortRangeLength; + /** Protocol Dest Port Range used in the Service Flow*/ + B_UINT8 u8ProtocolDestPortRange[PROTOCOL_DEST_PORT_RANGE_LENGTH]; + /** Length of Ethernet Destination MAC Address */ + B_UINT8 u8EthernetDestMacAddressLength; + /** Ethernet Destination MAC Address used in classification of the Service Flow*/ + B_UINT8 u8EthernetDestMacAddress[ETHERNET_DEST_MAC_ADDR_LENGTH]; + /** Length of Ethernet Source MAC Address */ + B_UINT8 u8EthernetSourceMACAddressLength; + /** Ethernet Source MAC Address used in classification of the Service Flow*/ + B_UINT8 u8EthernetSourceMACAddress[ETHERNET_SRC_MAC_ADDR_LENGTH]; + /** Length of Ethertype */ + B_UINT8 u8EthertypeLength; + /** 3bytes Ethertype Of The Service Flow*/ + B_UINT8 u8Ethertype[NUM_ETHERTYPE_BYTES]; + /** 8bit Associated PHSI Of The Service Flow*/ + B_UINT8 u8AssociatedPHSI; + /** Length of Vendor Specific Classifier Param length Of The Service Flow*/ + B_UINT8 u8VendorSpecificClassifierParamLength; + /** Vendor Specific Classifier Param Of The Service Flow*/ + B_UINT8 u8VendorSpecificClassifierParam[VENDOR_CLASSIFIER_PARAM_LENGTH]; + /** Length Of IPv6 Flow Lable of the Service Flow*/ + B_UINT8 u8IPv6FlowLableLength; + /** IPv6 Flow Lable Of The Service Flow*/ + B_UINT8 u8IPv6FlowLable[NUM_IPV6_FLOWLABLE_BYTES]; + /** Action associated with the classifier rule*/ + B_UINT8 u8ClassifierActionRule; + B_UINT16 u16ValidityBitMap; +}; +#ifndef BECEEM_TARGET +typedef struct _stCPacketClassificationRuleSI CCPacketClassificationRuleSI,stCPacketClassificationRuleSI, *pstCPacketClassificationRuleSI; +#endif + +/// \brief class CPhsRuleSI +#ifdef BECEEM_TARGET +class CPhsRuleSI{ + public: + /// \brief Constructor for the class + CPhsRuleSI(): + u8PHSI(mPHSI), + u8PHSFLength(0), + u8PHSMLength(0), + u8PHSS(mPHSS), + u8PHSV(mPHSV), + u8VendorSpecificPHSParamsLength(mVendorSpecificPHSParamLength){} + void Reset() + { + CPhsRuleSI(); + } +#else +typedef struct _stPhsRuleSI { +#endif + /** 8bit PHS Index Of The Service Flow*/ + B_UINT8 u8PHSI; + /** PHSF Length Of The Service Flow*/ + B_UINT8 u8PHSFLength; + /** String of bytes containing header information to be supressed by the sending CS and reconstructed by the receiving CS*/ + B_UINT8 u8PHSF[MAX_PHS_LENGTHS]; + /** PHSM Length Of The Service Flow*/ + B_UINT8 u8PHSMLength; + /** PHS Mask for the SF*/ + B_UINT8 u8PHSM[MAX_PHS_LENGTHS]; + /** 8bit Total number of bytes to be supressed for the Service Flow*/ + B_UINT8 u8PHSS; + /** 8bit Indicates whether or not Packet Header contents need to be verified prior to supression */ + B_UINT8 u8PHSV; + /** Vendor Specific PHS param Length Of The Service Flow*/ + B_UINT8 u8VendorSpecificPHSParamsLength; + /** Vendor Specific PHS param Of The Service Flow*/ + B_UINT8 u8VendorSpecificPHSParams[VENDOR_PHS_PARAM_LENGTH]; + + B_UINT8 u8Padding[2]; +#ifdef BECEEM_TARGET +}; +#else +}stPhsRuleSI,*pstPhsRuleSI; +typedef stPhsRuleSI CPhsRuleSI; +#endif + +/// \brief structure cConvergenceSLTypes +#ifdef BECEEM_TARGET +class CConvergenceSLTypes{ + public: + /// \brief Constructor for the class + CConvergenceSLTypes(): + u8ClassfierDSCAction(mClassifierDSCAction), + u8PhsDSCAction (mPhsDSCAction) + {} + void Reset() + { + CConvergenceSLTypes(); + cCPacketClassificationRule.Reset(); + cPhsRule.Reset(); + } +#else +struct _stConvergenceSLTypes{ +#endif + /** 8bit Phs Classfier Action Of The Service Flow*/ + B_UINT8 u8ClassfierDSCAction; + /** 8bit Phs DSC Action Of The Service Flow*/ + B_UINT8 u8PhsDSCAction; + /** 16bit Padding */ + B_UINT8 u8Padding[2]; + /// \brief class cCPacketClassificationRule +#ifdef BECEEM_TARGET + CCPacketClassificationRuleSI cCPacketClassificationRule; +#else + stCPacketClassificationRuleSI cCPacketClassificationRule; +#endif + /// \brief class CPhsRuleSI +#ifdef BECEEM_TARGET + CPhsRuleSI cPhsRule; +#else + struct _stPhsRuleSI cPhsRule; +#endif +}; +#ifndef BECEEM_TARGET +typedef struct _stConvergenceSLTypes stConvergenceSLTypes,CConvergenceSLTypes, *pstConvergenceSLTypes; +#endif + + +/// \brief structure CServiceFlowParamSI +#ifdef BECEEM_TARGET +class CServiceFlowParamSI{ + public: + /// \brief Constructor for the class + CServiceFlowParamSI(): + u32SFID(mSFid), + u16CID(mCid), + u8ServiceClassNameLength(mServiceClassNameLength), + u8MBSService(mMBSService), + u8QosParamSet(mQosParamSetType), + u8TrafficPriority(mTrafficPriority), + u32MaxSustainedTrafficRate(mMaximumSustainedTrafficRate), + u32MaxTrafficBurst(mMaximumTrafficBurst), + u32MinReservedTrafficRate(mMinimumReservedTrafficRate), + u8ServiceFlowSchedulingType(mServiceFlowSchedulingType), + u8RequesttransmissionPolicy(mRequestTransmissionPolicy), + u32ToleratedJitter(mToleratedJitter), + u32MaximumLatency(mMaximumLatency), + u8FixedLengthVSVariableLengthSDUIndicator + (mFixedLengthVSVariableLength), + u8SDUSize(mSDUSize), + u16TargetSAID(mTargetSAID), + u8ARQEnable(mARQEnable), + u16ARQWindowSize(mARQWindowSize), + u16ARQBlockLifeTime(mARQBlockLifeTime), + u16ARQSyncLossTimeOut(mARQSyncLossTimeOut), + u8ARQDeliverInOrder(mARQDeliverInOrder), + u16ARQRxPurgeTimeOut(mARQRXPurgeTimeOut), + //Add ARQ BLOCK SIZE, ARQ TX and RX delay initializations here + //after we move to only CORR2 + u8RxARQAckProcessingTime(mRxARQAckProcessingTime), + u8CSSpecification(mCSSpecification), + u8TypeOfDataDeliveryService(mTypeOfDataDeliveryService), + u16SDUInterArrivalTime(mSDUInterArrivalTime), + u16TimeBase(mTimeBase), + u8PagingPreference(mPagingPreference), + u8MBSZoneIdentifierassignment(mMBSZoneIdentifierassignmentLength), + u8TrafficIndicationPreference(mTrafficIndicationPreference), + u8GlobalServicesClassNameLength(mGlobalServicesClassNameLength), + u8SNFeedbackEnabled(mSNFeedbackEnabled), + u8FSNSize(mFSNSize), + u8CIDAllocation4activeBSsLength(mCIDAllocation4activeBSsLength), + u16UnsolicitedGrantInterval(mUnsolicitedGrantInterval), + u16UnsolicitedPollingInterval(mUnsolicitedPollingInterval), + u8PDUSNExtendedSubheader4HarqReordering(mPDUSNExtendedSubheader4HarqReordering), + u8MBSContentsIDLength(mMBSContentsIDLength), + u8HARQServiceFlows(mHARQServiceFlows), + u8AuthTokenLength(mAuthTokenLength), + u8HarqChannelMappingLength(mHarqChannelMappingLength), + u8VendorSpecificQoSParamLength(mVendorSpecificQoSParamLength), + bValid(FALSE), + u8TotalClassifiers() +{ +//Remove the bolck after we move to Corr2 only code +#ifdef ENABLE_CORRIGENDUM2_UPDATE + if((g_u32Corr2MacFlags & CORR_2_DSX) || (g_u32Corr2MacFlags & CORR_2_ARQ)) + { + /* IEEE Comment #627 / MTG Comment #426 */ + u16ARQBlockSize = mARQBlockSize; + if(g_u32Corr2MacFlags & CORR_2_ARQ) { + u16ARQRetryTxTimeOut = mARQRetryTimeOutTxDelay; + if(g_u32VENDOR_TYPE == VENDOR_ALCATEL) { + u16ARQRetryRxTimeOut = mARQRetryTimeOutRxDelay_ALU; + } else { + u16ARQRetryRxTimeOut = mARQRetryTimeOutRxDelay; + } + } + else + { + u16ARQRetryTxTimeOut = mARQRetryTimeOutTxDelayCorr1; + u16ARQRetryRxTimeOut = mARQRetryTimeOutRxDelayCorr1; + } + } + else +#endif + { + u16ARQBlockSize = mARQBlockSizeCorr1; + u16ARQRetryTxTimeOut = mARQRetryTimeOutTxDelayCorr1; + u16ARQRetryRxTimeOut = mARQRetryTimeOutRxDelayCorr1; + } +} + + void ComputeMacOverhead(B_UINT8 u8SecOvrhead); + B_UINT16 GetMacOverhead() { return u16MacOverhead; } +#else +typedef struct _stServiceFlowParamSI{ +#endif //end of ifdef BECEEM_TARGET + + /** 32bitSFID Of The Service Flow*/ + B_UINT32 u32SFID; + + /** 32bit Maximum Sustained Traffic Rate of the Service Flow*/ + B_UINT32 u32MaxSustainedTrafficRate; + + /** 32bit Maximum Traffic Burst allowed for the Service Flow*/ + B_UINT32 u32MaxTrafficBurst; + + /** 32bit Minimum Reserved Traffic Rate of the Service Flow*/ + B_UINT32 u32MinReservedTrafficRate; + + /** 32bit Tolerated Jitter of the Service Flow*/ + B_UINT32 u32ToleratedJitter; + + /** 32bit Maximum Latency of the Service Flow*/ + B_UINT32 u32MaximumLatency; + + /** 16bitCID Of The Service Flow*/ + B_UINT16 u16CID; + + /** 16bit SAID on which the service flow being set up shall be mapped*/ + B_UINT16 u16TargetSAID; + + /** 16bit ARQ window size negotiated*/ + B_UINT16 u16ARQWindowSize; + + /** 16bit Total Tx delay incl sending, receiving & processing delays */ + B_UINT16 u16ARQRetryTxTimeOut; + + /** 16bit Total Rx delay incl sending, receiving & processing delays */ + B_UINT16 u16ARQRetryRxTimeOut; + + /** 16bit ARQ block lifetime */ + B_UINT16 u16ARQBlockLifeTime; + + /** 16bit ARQ Sync loss timeout*/ + B_UINT16 u16ARQSyncLossTimeOut; + + /** 16bit ARQ Purge timeout */ + B_UINT16 u16ARQRxPurgeTimeOut; +#if 0 //def ENABLE_CORRIGENDUM2_UPDATE +/* IEEE Comment #627 / MTG Comment #426 */ + /// \brief Size of an ARQ block, changed from 2 bytes to 1 + B_UINT8 u8ARQBlockSize; +#endif +//TODO::Remove this once we move to a new CORR2 driver + /// \brief Size of an ARQ block + B_UINT16 u16ARQBlockSize; + +//#endif + /** 16bit Nominal interval b/w consecutive SDU arrivals at MAC SAP*/ + B_UINT16 u16SDUInterArrivalTime; + + /** 16bit Specifies the time base for rate measurement */ + B_UINT16 u16TimeBase; + + /** 16bit Interval b/w Successive Grant oppurtunities*/ + B_UINT16 u16UnsolicitedGrantInterval; + + /** 16bit Interval b/w Successive Polling grant oppurtunities*/ + B_UINT16 u16UnsolicitedPollingInterval; + + /** internal var to get the overhead */ + B_UINT16 u16MacOverhead; + + /** MBS contents Identifier*/ + B_UINT16 u16MBSContentsID[MBS_CONTENTS_ID_LENGTH]; + + /** MBS contents Identifier length*/ + B_UINT8 u8MBSContentsIDLength; + + /** ServiceClassName Length Of The Service Flow*/ + B_UINT8 u8ServiceClassNameLength; + + /** 32bytes ServiceClassName Of The Service Flow*/ + B_UINT8 u8ServiceClassName[32]; + + /** 8bit Indicates whether or not MBS service is requested for this Serivce Flow*/ + B_UINT8 u8MBSService; + + /** 8bit QOS Parameter Set specifies proper application of QoS paramters to Provisioned, Admitted and Active sets*/ + B_UINT8 u8QosParamSet; + + /** 8bit Traffic Priority Of the Service Flow */ + B_UINT8 u8TrafficPriority; + + /** 8bit Uplink Grant Scheduling Type of The Service Flow */ + B_UINT8 u8ServiceFlowSchedulingType; + + /** 8bit Request transmission Policy of the Service Flow*/ + B_UINT8 u8RequesttransmissionPolicy; + + /** 8bit Specifies whether SDUs for this Service flow are of FixedLength or Variable length */ + B_UINT8 u8FixedLengthVSVariableLengthSDUIndicator; + + /** 8bit Length of the SDU for a fixed length SDU service flow*/ + B_UINT8 u8SDUSize; + + /** 8bit Indicates whether or not ARQ is requested for this connection*/ + B_UINT8 u8ARQEnable; + + /**< 8bit Indicates whether or not data has tobe delivered in order to higher layer*/ + B_UINT8 u8ARQDeliverInOrder; + + /** 8bit Receiver ARQ ACK processing time */ + B_UINT8 u8RxARQAckProcessingTime; + + /** 8bit Convergence Sublayer Specification Of The Service Flow*/ + B_UINT8 u8CSSpecification; + + /** 8 bit Type of data delivery service*/ + B_UINT8 u8TypeOfDataDeliveryService; + + /** 8bit Specifies whether a service flow may generate Paging */ + B_UINT8 u8PagingPreference; + + /** 8bit Indicates the MBS Zone through which the connection or virtual connection is valid */ + B_UINT8 u8MBSZoneIdentifierassignment; + + /** 8bit Specifies whether traffic on SF should generate MOB_TRF_IND to MS in sleep mode*/ + B_UINT8 u8TrafficIndicationPreference; + + /** 8bit Speciifes the length of predefined Global QoS parameter set encoding for this SF */ + B_UINT8 u8GlobalServicesClassNameLength; + + /** 6 byte Speciifes the predefined Global QoS parameter set encoding for this SF */ + B_UINT8 u8GlobalServicesClassName[GLOBAL_SF_CLASSNAME_LENGTH]; + + /** 8bit Indicates whether or not SN feedback is enabled for the conn */ + B_UINT8 u8SNFeedbackEnabled; + + /** Indicates the size of the Fragment Sequence Number for the connection */ + B_UINT8 u8FSNSize; + + /** 8bit Number of CIDs in active BS list */ + B_UINT8 u8CIDAllocation4activeBSsLength; + + /** CIDs of BS in the active list */ + B_UINT8 u8CIDAllocation4activeBSs[MAX_NUM_ACTIVE_BS]; + + /** Specifies if PDU extended subheader should be applied on every PDU on this conn*/ + B_UINT8 u8PDUSNExtendedSubheader4HarqReordering; + + /** 8bit Specifies whether the connection uses HARQ or not */ + B_UINT8 u8HARQServiceFlows; + + /** Specifies the length of Authorization token*/ + B_UINT8 u8AuthTokenLength; + + /** Specifies the Authorization token*/ + B_UINT8 u8AuthToken[AUTH_TOKEN_LENGTH]; + + /** specifes Number of HARQ channels used to carry data length*/ + B_UINT8 u8HarqChannelMappingLength; + + /** specifes HARQ channels used to carry data*/ + B_UINT8 u8HARQChannelMapping[NUM_HARQ_CHANNELS]; + + /** 8bit Length of Vendor Specific QoS Params */ + B_UINT8 u8VendorSpecificQoSParamLength; + + /** 1byte Vendor Specific QoS Param Of The Service Flow*/ + B_UINT8 u8VendorSpecificQoSParam[VENDOR_SPECIF_QOS_PARAM]; + + // indicates total classifiers in the SF + B_UINT8 u8TotalClassifiers; /**< Total number of valid classifiers*/ + B_UINT8 bValid; /**< Validity flag */ + B_UINT8 u8Padding; /**< Padding byte*/ + +#ifdef BECEEM_TARGET +/** +Structure for Convergence SubLayer Types with a maximum of 4 classifiers +*/ + CConvergenceSLTypes cConvergenceSLTypes[MAX_CLASSIFIERS_IN_SF]; +#else +/** +Structure for Convergence SubLayer Types with a maximum of 4 classifiers +*/ + stConvergenceSLTypes cConvergenceSLTypes[MAX_CLASSIFIERS_IN_SF]; +#endif + +#ifdef BECEEM_TARGET +}; +#else +} stServiceFlowParamSI, *pstServiceFlowParamSI; +typedef stServiceFlowParamSI CServiceFlowParamSI; +#endif + +/** +structure stLocalSFAddRequest +*/ +typedef struct _stLocalSFAddRequest{ +#ifdef BECEEM_TARGET + _stLocalSFAddRequest( ) : + u8Type(0x00), eConnectionDir(0x00), + u16TID(0x0000), u16CID(0x0000), u16VCID(0x0000) + {} +#endif + + B_UINT8 u8Type; /**< Type*/ + B_UINT8 eConnectionDir; /**< Connection direction*/ + /// \brief 16 bit TID + B_UINT16 u16TID; /**< 16bit TID*/ + /// \brief 16bitCID + B_UINT16 u16CID; /**< 16bit CID*/ + /// \brief 16bitVCID + B_UINT16 u16VCID; /**< 16bit VCID*/ + /// \brief structure ParameterSet +#ifdef BECEEM_SIGNALLING_INTERFACE_API + CServiceFlowParamSI sfParameterSet; +#endif + +#ifdef BECEEM_TARGET + CServiceFlowParamSI *psfParameterSet; +#else + stServiceFlowParamSI *psfParameterSet; /**< structure ParameterSet*/ +#endif + +#ifdef USING_VXWORKS + USE_DATA_MEMORY_MANAGER(); +#endif +}stLocalSFAddRequest, *pstLocalSFAddRequest; + + +/** +structure stLocalSFAddIndication +*/ +typedef struct _stLocalSFAddIndication{ +#ifdef BECEEM_TARGET + _stLocalSFAddIndication( ) : + u8Type(0x00), eConnectionDir(0x00), + u16TID(0x0000), u16CID(0x0000), u16VCID(0x0000) + {} +#endif + + B_UINT8 u8Type; /**< Type*/ + B_UINT8 eConnectionDir; /**< Connection Direction*/ + /// \brief 16 bit TID + B_UINT16 u16TID; /**< TID*/ + /// \brief 16bitCID + B_UINT16 u16CID; /**< 16bitCID*/ + /// \brief 16bitVCID + B_UINT16 u16VCID; /**< 16bitVCID*/ + +#ifdef BECEEM_SIGNALLING_INTERFACE_API + CServiceFlowParamSI sfAuthorizedSet; + /// \brief structure AdmittedSet + CServiceFlowParamSI sfAdmittedSet; + /// \brief structure ActiveSet + CServiceFlowParamSI sfActiveSet; +#endif + + /// \brief structure AuthorizedSet +#ifdef BECEEM_TARGET + CServiceFlowParamSI *psfAuthorizedSet; + /// \brief structure AdmittedSet + CServiceFlowParamSI *psfAdmittedSet; + /// \brief structure ActiveSet + CServiceFlowParamSI *psfActiveSet; +#else + /// \brief structure AuthorizedSet + stServiceFlowParamSI *psfAuthorizedSet; /**< AuthorizedSet of type stServiceFlowParamSI*/ + /// \brief structure AdmittedSet + stServiceFlowParamSI *psfAdmittedSet; /**< AdmittedSet of type stServiceFlowParamSI*/ + /// \brief structure ActiveSet + stServiceFlowParamSI *psfActiveSet; /**< sfActiveSet of type stServiceFlowParamSI*/ +#endif + B_UINT8 u8CC; /**< Confirmation Code*/ + B_UINT8 u8Padd; /**< 8-bit Padding */ + + B_UINT16 u16Padd; /**< 16 bit Padding */ + +#ifdef USING_VXWORKS + USE_DATA_MEMORY_MANAGER(); +#endif +}stLocalSFAddIndication; + + +typedef struct _stLocalSFAddIndication *pstLocalSFAddIndication; +/** +structure stLocalSFChangeRequest is same as structure stLocalSFAddIndication +*/ +typedef struct _stLocalSFAddIndication stLocalSFChangeRequest, *pstLocalSFChangeRequest; +/** +structure stLocalSFChangeIndication is same as structure stLocalSFAddIndication +*/ +typedef struct _stLocalSFAddIndication stLocalSFChangeIndication, *pstLocalSFChangeIndication; + +/** +structure stLocalSFDeleteRequest +*/ +typedef struct _stLocalSFDeleteRequest{ +#ifdef BECEEM_TARGET + _stLocalSFDeleteRequest( ) : + u8Type(0x00), u8Padding(0x00), + u16TID(0x0000), u32SFID (0x00000000) + {} +#endif + B_UINT8 u8Type; /**< Type*/ + B_UINT8 u8Padding; /**< Padding byte*/ + B_UINT16 u16TID; /**< TID*/ + /// \brief 32bitSFID + B_UINT32 u32SFID; /**< SFID*/ +#ifdef USING_VXWORKS + USE_DATA_MEMORY_MANAGER(); +#endif +}stLocalSFDeleteRequest, *pstLocalSFDeleteRequest; + +/** +structure stLocalSFDeleteIndication +*/ +typedef struct stLocalSFDeleteIndication{ +#ifdef BECEEM_TARGET + stLocalSFDeleteIndication( ) : + u8Type(0x00), u8Padding(0x00), + u16TID(0x0000), u16CID(0x0000), + u16VCID(0x0000),u32SFID (0x00000000) + {} +#endif + B_UINT8 u8Type; /**< Type */ + B_UINT8 u8Padding; /**< Padding */ + B_UINT16 u16TID; /**< TID */ + /// \brief 16bitCID + B_UINT16 u16CID; /**< CID */ + /// \brief 16bitVCID + B_UINT16 u16VCID; /**< VCID */ + /// \brief 32bitSFID + B_UINT32 u32SFID; /**< SFID */ + /// \brief 8bit Confirmation code + B_UINT8 u8ConfirmationCode; /**< Confirmation code */ + B_UINT8 u8Padding1[3]; /**< 3 byte Padding */ +#ifdef USING_VXWORKS + USE_DATA_MEMORY_MANAGER(); +#endif +}stLocalSFDeleteIndication; + +typedef struct _stIM_SFHostNotify +{ + B_UINT32 SFID; //SFID of the service flow + B_UINT16 newCID; //the new/changed CID + B_UINT16 VCID; //Get new Vcid if the flow has been made active in CID update TLV, but was inactive earlier or the orig vcid + B_UINT8 RetainSF; //Indication to Host if the SF is to be retained or deleted; if TRUE-retain else delete + B_UINT8 QoSParamSet; //QoS paramset of the retained SF + B_UINT16 u16reserved; //For byte alignment + +} stIM_SFHostNotify; + +#endif |
