diff -r 000000000000 -r c40eb8fe8501 wlan_bearer/wlanldd/wlan_common/umac_common/inc/UmacContextImpl.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wlan_bearer/wlanldd/wlan_common/umac_common/inc/UmacContextImpl.h Tue Feb 02 02:03:13 2010 +0200 @@ -0,0 +1,2122 @@ +/* +* Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Declaration of the UmacContextImpl class +* +*/ + +/* +* %version: 102 % +*/ + +#ifndef WLANCONTEXTIMPL_H +#define WLANCONTEXTIMPL_H + +#ifndef RD_WLAN_DDK +#include +#else +#include +#endif + +#include "Umac.h" +#include "FrameXferBlock.h" + +#include "802dot11.h" +#include "umacinternaldefinitions.h" +#include "UmacMib.h" +#include "UmacAuthSeqNmbrExpected.h" +#include "umaceventdispatcher.h" +#include "umacpacketscheduler.h" +#include "umacpacketschedulerclient.h" +#include "umacnullsender.h" + +#include "UmacDot11MacError.h" +#include "UmacDot11InitPhase1.h" +#include "UmacDot11Idle.h" + +#include "UmacDot11PrepareForBssMode.h" +#include "UmacDot11DisassociationPending.h" +#include "UmacDot11Synchronize.h" +#include "umacdot11idlescanningmode.h" + +#include "UmacDot11ReassociationPending.h" +#include "UmacDot11SoftReset.h" +#include "UmacDot11OpenAuthPending.h" +#include "UmacDot11SharedAuthPending.h" +#include "UmacDot11AssociationPending.h" +#include "UmacDot11DeauthPending.h" +#include "UmacDot11InfrastructureModeInit.h" +#include "UmacDot11PrepareForIbssMode.h" +#include "umacdot11ibssnormalmode.h" +#include "umacdot11ibssscanningmode.h" +#include "umacdot11infrastructurenormalmode.h" +#include "umacdot11infrastructurescanningmode.h" +#include "umacdot11pwrmgmttransitionmode.h" +#include "UmacDot11MibDefaultConfigure.h" + +#include "umacconnectcontext.h" +#include "umacprivacymodefilters.h" +#include "UmacTxRateAdaptation.h" +#include "UmacPRNGenerator.h" +#include "umacusertxdatacntx.h" +#include "umacdynamicpowermodemgmtcntx.h" +#include "umacnullsendcontroller.h" +#include "umacsignalpredictor.h" + +class WlanMacState; +class WlanConnectContext; +class UmacManagementSideUmacCb; +class WlanAddBroadcastWepKey; +class WlanConfigureTxQueueParams; +class WlanConfigureTxAutoRatePolicy; +class WlanWsaInitiliaze; +class WlanWsaConfigure; +class WlanWsaJoin; +class WlanWsaScan; +class WlanWhaStopScan; +class WlanWsaReadMib; +class WlanWsaWriteMib; +class WlanWsaDisconnect; +class WlanWsaSetBssParameters; +class WlanWsaAddKey; +class WlanWsaRemoveKey; +class WlanWsaSetPsMode; +class WlanWhaConfigureQueue; +class WlanWhaConfigureAc; +class WlanWhaRelease; + +struct SWsaCommands; + + +/** +* WLAN context implementation +*/ +class WlanContextImpl : + public WHA::MWhaCb, + public MWlanPacketSchedulerClient, + public MWlanNullSender + { + +public: + + /** + * Return value type for AddMulticastAddress() method + */ + enum TGroupAddStatus + { + EOk, + EFull, + EAlreadyExists + }; + + /** + * Lookup table to map 802.11 rate defintions + */ + class SupportedRateLookUp + { + public: // Methods + + /** Ctor */ + SupportedRateLookUp() : + // these initial values don't really matter as they are always + // overwritten + iSupportedRate( E802Dot11Rate1MBit ), iWsaRate( 0 ) {}; + + private: // Methods + + // Prohibit copy constructor + SupportedRateLookUp( const SupportedRateLookUp& ); + // Prohibit assigment operator + SupportedRateLookUp& operator== ( const SupportedRateLookUp&); + + public: // Data + + /** 802.11 rate defintions */ + T802Dot11SupportedRate iSupportedRate; + /** corresponding WHA rate */ + TUint32 iWsaRate; + }; + +protected: + + /** + * The states of the statemachine + */ + struct States + { + public: // Methods + + /** + * Ctor + */ + States() {}; + + private: // Methods + + // Prohibit assignment operator + States& operator= ( const States& ); + // Prohibit copy constructor + States( const States& ); + + public: // Data + WlanDot11InitPhase1 iInitPhase1State; + WlanDot11MibDefaultConfigure iMibDefaultConfigure; + WlanDot11Idle iIdleState; + WlanDot11PrepareForBssMode iPrepareForBssMode; + WlanDot11PrepareForIbssMode iPrepareForIbssMode; + WlanDot11OpenAuthPending iOpenAuthPendingState; + WlanDot11SharedAuthPending iSharedAuthPending; + WlanDot11AssociationPending iAssociationPendingState; + WlanDot11InfrastructureModeInit iInfrastructureModeInit; + WlanDot11IdleScanningMode iIdleScanningMode; + WlanDot11IbssNormalMode iIbssNormalMode; + WlanDot11IbssScanningMode iIbssScanningMode; + WlanDot11InfrastructureScanningMode + iInfrastructureScanningMode; + WlanDot11InfrastructureNormalMode + iInfrastructureNormalMode; + WlanDot11PwrMgmtTransitionMode iPwrMgmtTransitionMode; + WlanDot11DisassociationPending iDisassociationPendingState; + WlanDot11Synchronize iSynchronizeState; + WlanDot11ReassociationPending iReassociationPendingState; + WlanDot11DeauthPending iDeauthPendingState; + WlanDot11SoftReset iSoftResetState; + WlanDot11MacError iMacError; + }; + + /** + * 802.11 management frame templates + */ + class ManagementFrameTemplates + { + public: // Methods + + /** Ctor */ + ManagementFrameTemplates() : + ialign1( 0 ), + ialign2( 0 ), + ialign3( 0 ), + ialign4( 0 ), + ialign5( 0 ), + ialign6( 0 ), + ialign7( 0 ), + ialign8( 0 ), + ialign9( 0 ) + {}; + + private: // Methdods + + // Prohibit copy constructor + ManagementFrameTemplates( const ManagementFrameTemplates& ); + // Prohibit assigment operator + ManagementFrameTemplates& operator== ( + const ManagementFrameTemplates& ); + + public: // Data + + /** authenticate frame template */ + SAuthenticationFrame iAuthenticationFrame; + /** + * 32-bit align + * only needed because these structs are packed + */ + TUint32 ialign1; + /** authenticate frame template with HT Control field */ + SHtAuthenticationFrame iHtAuthenticationFrame; + /** + * 32-bit align + * only needed because these structs are packed + */ + TUint32 ialign2; + /** association frame template */ + SAssociationRequestFrame iAssociationRequestFrame; + /** + * 32-bit align + * only needed because these structs are packed + */ + TUint32 ialign3; + /** association frame template with HT Control field */ + SHtAssociationRequestFrame iHtAssociationRequestFrame; + /** + * 32-bit align + * only needed because these structs are packed + */ + TUint32 ialign4; + /** deauthenticate frame template */ + SDeauthenticateFrame iDeauthenticateFrame; + /** + * 32-bit align + * only needed because these structs are packed + */ + TUint32 ialign5; + /** deauthenticate frame template with HT Control field */ + SHtDeauthenticateFrame iHtDeauthenticateFrame; + /** + * 32-bit align + * only needed because these structs are packed + */ + TUint32 ialign6; + /** disassociation frame template */ + SDisassociateFrame iDisassociationFrame; + /** + * 32-bit align + * only needed because these structs are packed + */ + TUint32 ialign7; + /** disassociation frame template with HT Control field */ + SHtDisassociateFrame iHtDisassociationFrame; + /** + * 32-bit align + * only needed because these structs are packed + */ + TUint32 ialign8; + /** resassociation frame template */ + SReassociationRequestFrame iReassociationRequestFrame; + /** + * 32-bit align + * only needed because these structs are packed + */ + TUint32 ialign9; + /** resassociation frame template with HT Control field */ + SHtReassociationRequestFrame iHtReassociationRequestFrame; + }; + + /** + * Container for multicast groups (specified by group mac addresses) + * that we have joined. + * + * When we have joined any multicast groups + * we would like to receive only multicast packets that have been + * sent to those groups. + */ + class JoinedMulticastGroups + { + public: + + /** Ctor */ + JoinedMulticastGroups(); + + /** + * Adds a group. + * @param + * @return ETrue if aGroup was not fou + */ + TGroupAddStatus AddGroup( const TMacAddress& aGroup ); + + /** + * Removes a group. + * @param aGroup Group to be removed + * @return ETrue if aGroup was found (and hence removed) + * EFalse otherwise + */ + TBool RemoveGroup( const TMacAddress& aGroup ); + + /** + * Returns the number of groups that we are joined into + * currently. + * @return The number of groups joined currently. + */ + TUint8 Count() const; + + /** + * Gets all the groups by passing back a pointer to the 1st + * group which is followed by all the other groups that + * we are joined into. + * @return The number of groups (group addresses) returned + */ + TUint8 GetGroups( const TMacAddress*& aGroups ) const; + + /** + * Clears the whole container by removing all groups from it + */ + void Reset(); + + private: + + /** + * Finds aGroup + * @param aGroup Group to be located + * @param aIndex Index pointing to aGroup if aGroup was found + * @return ETrue if aGroup was found + * EFalse otherwise + */ + TBool FindGroup( + const TMacAddress& aGroup, + TUint& aIndex ) const; + + // Prohibit copy constructor + JoinedMulticastGroups( const JoinedMulticastGroups& ); + // Prohibit assigment operator + JoinedMulticastGroups& operator= + ( const JoinedMulticastGroups& ); + + private: // Data + + /** + * The maximum number of multicast groups that we allow. + * Note that the adaptation layer may support also + * any smaller number of addresses, including zero + */ + enum { KMaxNbrOfGroups = 32 }; + + /** storage for group entries */ + TMacAddress iStorage[KMaxNbrOfGroups]; + + /** is the corresponding storage entry free */ + TBool iFree[KMaxNbrOfGroups]; + + /** + * 1st free index. As there are no empty storage entries in + * the middle, this is also the number of groups that we are + * joined into currently */ + TUint8 iFirstFreeIndex; + }; + +public: + + /** + * C++ constructor. + * @param WlanContext context that owns us + */ + explicit WlanContextImpl( Umac& aUmac ); + + /** + * Dtor + */ + virtual ~WlanContextImpl(); + + /** + * Constructs our supported rates lookup table + */ + void MakeLookUpTable(); + + void AttachWsa( WHA::Wha* aWha ); + void BootUp( + const TUint8* aPda, + TUint32 aPdaLength, + const TUint8* aFw, + TUint32 aFwLength ); + inline WlanManagementSideUmacCb& WlanManagementSideCb() { return iUmac; } + inline WHA::Wha& Wha() { return *iWha; } + inline WlanMacState& CurrentState(); + + TBool OnDeferredWhaCommandComplete( + WHA::TCompleteCommandId aCompleteCommandId, + WHA::TStatus aStatus, + const WHA::UCommandCompletionParams& aCommandCompletionParams ); + + TBool OnDeferredInternalEvent( TInternalEvent aInternalEvent ); + + inline void RegisterEvent( const TOIDHeader& aOid ); + + inline void RegisterEvent( TInternalEvent aInternalEvent ); + + inline TBool ChannelEnabled( WlanEventDispatcher::TChannel aChannel ) const; + + inline void Enable( WlanEventDispatcher::TChannel aChannelMask ); + inline void Disable( WlanEventDispatcher::TChannel aChannelMask ); + + inline TBool DispatchEvent(); + + /** + * Determines if a command completion event for the specified + * command is registered + * + * @param aCommandId Id of the command to check + * @return ETrue if command completion event is registered + * EFalse otherwise + */ + inline TBool CommandCompletionEventRegistered( + WHA::TCompleteCommandId aCommandId ) const; + + /** + * Dispatches a single command completion event + * + * @since S60 3.1 + * @return ETrue If a global state change occurred as a result of the event + * dispatching + * EFalse otherwise + */ + inline TBool DispatchCommandCompletionEvent(); + + inline TBool ProtocolStackTxDataAllowed() const; + + /** + * Second level initializer. Does statemachine initialization + * @return ETrue success EFalse failure + */ + TBool Initialize(); + + WlanAddBroadcastWepKey& AddBroadcastWepKey(); + WlanConfigureTxQueueParams& ConfigureTxQueueParams(); + WlanConfigureTxAutoRatePolicy& ConfigureTxAutoRatePolicy(); + WlanWsaInitiliaze& WsaInitiliaze(); + WlanWsaConfigure& WsaConfigure(); + WlanWsaReadMib& WsaReadMib(); + WlanWsaWriteMib& WsaWriteMib(); + WlanWsaJoin& WsaJoin(); + WlanWsaScan& WsaScan(); + WlanWhaStopScan& WhaStopScan(); + WlanWsaDisconnect& WsaDisconnect(); + WlanWsaSetBssParameters& WsaSetBssParameters(); + WlanWsaAddKey& WsaAddKey(); + WlanWhaConfigureQueue& WhaConfigureQueue(); + WlanWsaSetPsMode& WsaSetPsMode(); + WlanWhaConfigureAc& WhaConfigureAc(); + WlanWhaRelease& WlanWhaRelease(); + + inline void WHASettings( const WHA::SSettings& aSettings ); + inline WHA::SSettings& WHASettings(); + inline const WHA::SSettings& WHASettings() const; + + /** + * Gets authentication frame template + * @return authentication frame template + */ + inline SAuthenticationFrame& GetAuthenticationFrame(); + + /** + * Gets authentication frame template with HT Control field + * @return authentication frame template + */ + inline SHtAuthenticationFrame& GetHtAuthenticationFrame(); + + /** + * Gets association request frame template + * @return association request frame template + */ + inline SAssociationRequestFrame& GetAssociationRequestFrame(); + + /** + * Gets association request frame template with HT Control field + * @return association request frame template + */ + inline SHtAssociationRequestFrame& GetHtAssociationRequestFrame(); + + /** + * Gets deauthenticate frame template + * @return deauthenticate frame template + */ + inline SDeauthenticateFrame& GetDeauthenticateFrame(); + + /** + * Gets deauthenticate frame template with HT Control field + * @return deauthenticate frame template + */ + inline SHtDeauthenticateFrame& GetHtDeauthenticateFrame(); + + /** + * Gets disassociation frame template + * @return disassociation frame template + */ + inline SDisassociateFrame& GetDisassociationFrame(); + + /** + * Gets disassociation frame template with HT Control field + * @return disassociation frame template + */ + inline SHtDisassociateFrame& GetHtDisassociationFrame(); + + /** + * Gets resassociation frame template + * @return resassociation frame template + */ + inline SReassociationRequestFrame& GetReassociationRequestFrame(); + + /** + * Gets resassociation frame template with HT Control field + * @return resassociation frame template + */ + inline SHtReassociationRequestFrame& GetHtReassociationRequestFrame(); + + /** + * Gets null data frame template + * @return resassociation frame template + */ + inline SNullDataFrame& NullDataFrame(); + + /** + * Gets QoS Null data frame template + * @return QoS Null data frame template + */ + inline SHtQosNullDataFrame& QosNullDataFrame(); + + /** + * Returns the length of the QoS Null data frame template when we + * know our current/target network. + * It's the length of a HT QoS Null data frame in case of a HT nw + * and otherwise the length of a regular (non-HT) QoS Null data frame + * @return Length of the currently relevant QoS Null data frame + */ + inline TUint16 QosNullDataFrameLength() const; + + /** + * Gets data frame template + * @return data frame template + */ + inline SDataFrameHeader& GetDataFrameHeader(); + + /** + * Gets protocol stack side ethernet tx context + * @return protocol stack side ethernet write context + */ + inline TWlanUserTxDataCntx& GetTxDataCntx(); + inline const TWlanUserTxDataCntx& GetTxDataCntx() const; + + /** + * Gets EAPOL stack side ethernet tx context + * @return EAPOL stack side ethernet write context + */ + inline TWlanUserTxDataCntx& GetMgmtTxDataCntx(); + inline const TWlanUserTxDataCntx& GetMgmtTxDataCntx() const; + + /** + * Resets authentication sequnece expected counter to initial state + */ + inline void ResetAuthSeqNmbrExpected(); + + /** + * Gets the current Tx rate and related rate policy associated with the + * specified Tx queue + * + * @param aQueueId id of the Tx queue + * @param aUseSpecialRatePolicy If ETrue, the use of the special Tx rate + * policy is requested + * If EFalse, the use of the special Tx rate policy is not requested + * @param aRate initial max Tx rate to use; if relevant + * @param aPolicyId ID of the rate class / policy to use + */ + inline void TxRatePolicy( + WHA::TQueueId aQueueId, + TBool aUseSpecialRatePolicy, + WHA::TRate& aRate, + TUint8& aPolicyId ) const; + + /** + * Gets BSSID + * @return BSSID + */ + inline TMacAddress& GetBssId(); + + inline void Aid( const TUint32 aAid ); + inline TUint32 Aid() const; + + inline void AtimWindow( const TUint32 aAtimWindow ); + inline TUint32 AtimWindow() const; + + /** + * Gets SSID + * @return SSID + */ + inline TSSID& GetSsId(); + + /** + * Gets used privacy mode + * @return used privacy mode + */ + inline TEncryptionStatus& EncryptionStatus(); + + inline WHA::TOperationMode NetworkOperationMode() const; + inline void NetworkOperationMode( + WHA::TOperationMode aOperationMode ); + + // setters and getters for key type + inline void GroupKeyType( WHA::TKeyType aKeyType ); + inline WHA::TKeyType GroupKeyType() const; + inline void PairWiseKeyType( WHA::TKeyType aKeyType ); + inline WHA::TKeyType PairWiseKeyType() const; + + inline void PairwiseCipher( TWlanCipherSuite aCipherSuite ); + inline TWlanCipherSuite PairwiseCipher() const; + + inline WHA::TChannelNumber NetworkChannelNumeber() const; + inline void NetworkChannelNumeber( WHA::TChannelNumber aChannelNumber ); + + inline TUint32 NetworkBeaconInterval() const; + inline void NetworkBeaconInterval( TUint32 aBeaconInterval ); + + inline WHA::TPsMode DesiredDot11PwrMgmtMode() const; + inline void DesiredDot11PwrMgmtMode( WHA::TPsMode aPsMode ); + + inline WHA::TPsMode CurrentDot11PwrMgmtMode() const; + inline void CurrentDot11PwrMgmtMode( WHA::TPsMode aPsMode ); + + inline const TDot11PsModeWakeupSetting& DesiredPsModeConfig() const; + inline void SetDesiredPsModeConfig( + const TDot11PsModeWakeupSetting& aPsModeWakeupSetting ); + + TPowerMgmtMode CurrentPwrMgmtMode() const; + + inline WHA::TPsMode ClientDot11PwrMgmtMode() const; + inline void ClientDot11PwrMgmtMode( TPowerMode aPsMode ); + + inline const TDot11PsModeWakeupSetting& ClientLightPsModeConfig() const; + inline void SetClientLightPsModeConfig( + TWlanWakeUpInterval aWakeupMode, + TUint8 aListenInterval ); + + inline const TDot11PsModeWakeupSetting& ClientDeepPsModeConfig() const; + inline void SetClientDeepPsModeConfig( + TWlanWakeUpInterval aWakeupMode, + TUint8 aListenInterval ); + + inline TBool DynamicPwrModeMgtDisabled() const; + void DynamicPwrModeMgtDisabled( TBool aValue ); + + inline TBool UseShortPreamble() const; + void UseShortPreamble( TBool aValue ); + + inline TBool Reassociate() const; + void Reassociate( TBool aValue ); + + inline TBool UseShortSlotTime() const; + void UseShortSlotTime( TBool aValue ); + + inline TBool ProtectionBitSet() const; + void ProtectionBitSet( TBool aValue ); + + inline TBool QosEnabled() const; + void QosEnabled( TBool aValue ); + + inline TBool UapsdEnabled() const; + void UapsdEnabled( TBool aValue ); + + inline TBool MulticastFilteringDisAllowed() const; + void MulticastFilteringDisAllowed( TBool aValue ); + + inline TBool ErpIePresent() const; + void ErpIePresent( TBool aValue ); + + inline TBool DisassociatedByAp() const; + void DisassociatedByAp( TBool aValue ); + + inline TBool UapsdRequestedForVoice() const; + void UapsdRequestedForVoice( TBool aValue ); + + inline TBool UapsdRequestedForVideo() const; + void UapsdRequestedForVideo( TBool aValue ); + + inline TBool UapsdRequestedForBestEffort() const; + void UapsdRequestedForBestEffort( TBool aValue ); + + inline TBool UapsdRequestedForBackground() const; + void UapsdRequestedForBackground( TBool aValue ); + + inline TBool UapsdUsedForVoice() const; + void UapsdUsedForVoice( TBool aValue ); + + inline TBool UapsdUsedForVideo() const; + void UapsdUsedForVideo( TBool aValue ); + + inline TBool UapsdUsedForBestEffort() const; + void UapsdUsedForBestEffort( TBool aValue ); + + inline TBool UapsdUsedForBackground() const; + void UapsdUsedForBackground( TBool aValue ); + + inline TBool ApTestOpportunitySeekStarted() const; + void ApTestOpportunitySeekStarted( TBool aValue ); + + inline TBool ApTestOpportunityIndicated() const; + void ApTestOpportunityIndicated( TBool aValue ); + + inline TBool HtSupportedByNw() const; + void HtSupportedByNw( TBool aValue ); + + inline TUint8 WmmParameterSetCount() const; + inline void WmmParameterSetCount( TUint8 aValue ); + + inline TUint32 RateBitMask() const; + inline void RateBitMask( TUint32 aValue ); + + inline TCwMinVector& CwMinVector(); + inline TCwMaxVector& CwMaxVector(); + inline TAifsVector& AifsVector(); + inline TTxOplimitVector& TxOplimitVector(); + inline TAcmVector& AcmVector(); + /** + * Returns our Wmm IE + * @return WMM IE + */ + inline STxWmmIE& OurWmmIe(); + + /** + * Returns the WLAN Mgmt client provided Tx rate policy + * + * @since S60 3.1 + * @return Tx rate policy + */ + inline TTxRatePolicy& RatePolicy(); + + /** + * Returns the WLAN Mgmt client provided Tx queue to Tx rate policy mapping + * + * @since S60 3.1 + * @return Tx queue to Tx rate policy mapping + */ + inline TQueue2RateClass& Queue2RateClass(); + + /** + * Returns the WLAN Mgmt client provided initial max Tx rate for every + * Mgmt client provided rate policy object + * + * @since S60 3.1 + * @return initial max Tx rate for every relevant Tx rate policy object + */ + inline TInitialMaxTxRate4RateClass& InitialMaxTxRate4RateClass(); + + /** + * Returns the WLAN Mgmt client provided Tx auto rate policy + * + * @return Tx auto rate policy + */ + inline TTxAutoRatePolicy& AutoRatePolicy(); + + /** + * Returns the ID of the special Tx auto rate policy + * Returns zero if a special Tx auto rate policy is not available + * + * @return the ID of the special Tx auto rate policy, or zero + */ + inline TUint8 SpecialTxAutoRatePolicy() const; + + /** + * Sets the ID of the special Tx auto rate policy + * + * @param aPolicyId the ID of the special Tx auto rate policy. Zero + * if a special Tx auto rate policy is not available + */ + inline void SpecialTxAutoRatePolicy( TUint8 aPolicyId ); + + /** + * Returns the WLAN Mgmt client provided HT MCS policy + * + * @since S60 3.1 + * @return Tx rate policy + */ + inline THtMcsPolicy& HtMcsPolicy(); + + /** + * Returns the WLAN Mgmt client provided Maximum U-APSD Service Period + * length + * + * @since S60 3.2 + * @return Maximum U-APSD Service Period length + */ + inline TQosInfoUapsdMaxSpLen& UapsdMaxSpLen(); + + inline TUint32 WhaCommandAct() const; + inline void WhaCommandAct( TUint32 aAct ); + + inline TUint32 Random(); + + /** + * Returns reference to the authentication algorithm number to be used + * @return authentication algorithm number + */ + inline TUint16& AuthenticationAlgorithmNumber(); + + /** + * To be called upon every Tx frame send completion + * @param aRate actual rate transmitted + * @param aSuccess was the frame transmitted successfully or not + * @param aRequestedRate Tx rate that was originally requested + */ + inline void OnTxCompleted( + const TUint32 aRate, + const TBool aSuccess, + WHA::TQueueId aQueueId, + WHA::TRate aRequestedRate ); + + /** + * Gets buffer for Rx data + * + * @param aLengthinBytes Requested length of the buffer + * @param aInternal ETrue if the buffer request was triggered inside UMAC + * EFalse if it was triggered from WHA layer + * @return Pointer to the beginning of the buffer on success + * NULL if a buffer couldn't be allocated + */ + TUint8* GetRxBuffer( + const TUint16 aLengthinBytes, + TBool aInternal = EFalse ); + + /** + * Allocates Rx frame meta header + * @return Rx frame meta header upon success + * NULL otherwise + */ + TDataBuffer* GetRxFrameMetaHeader(); + + /** + * Deallocates Rx frame meta header + * @param aMetaHeader Meta header to deallocate + */ + void FreeRxFrameMetaHeader( TDataBuffer* aMetaHeader ); + + TUint8* TxBuffer( TBool aWaitIfNotFree = EFalse ); + + /** + * Cancels the default timer + */ + inline void CancelTimer(); + + /** + * Gets the authentication sequence number expected + * @return authentication sequence number expected + */ + inline TUint8 GetAuthSeqNmbrExpected() const; + + /** + * Gets our supported rates IE + * @return supported rates IE + */ + inline SSupportedRatesIE& GetOurSupportedRatesIE(); + + /** + * Gets our extended supported rates IE + * @return extended supported rates IE + */ + inline SExtendedSupportedRatesIE& GetOurExtendedSupportedRatesIE(); + + /** + * Stores a Beacon or Probe Response frame body from the + * network we are going to connect to + * + * @since S60 3.2 + * @param aBody pointer to the frame body + */ + inline void SetScanResponseFrameBody( const TUint8* aBody ); + + /** + * Returns a pointer to a Beacon or Probe Response frame body from the + * network we are going to connect to + * + * @since S60 3.2 + * @return pointer to the frame body + */ + inline const TUint8* ScanResponseFrameBody() const; + + /** + * Stores a Beacon or Probe Response frame body length + * + * @since S60 3.2 + * @param aLength frame body length + */ + inline void SetScanResponseFrameBodyLength( TUint16 aLength ); + + /** + * Returns the length of a Beacon or Probe Response frame body from the + * network we are going to connect to + * + * @since S60 3.2 + * @return length of the frame body + */ + inline const TUint16 ScanResponseFrameBodyLength() const; + + /** + * Stores the IE(s) to be included into the (re-)association request. + * + * @since S60 3.2 + * @param aIeData pointer to the IE(s). NULL, if none to be included + */ + inline void IeData( const TUint8* aIeData ); + + /** + * Returns the IE(s) to be included into the (re-)association request. + * + * @since S60 3.2 + * @return pointer to the IE(s). NULL, if none to be included + */ + inline const TUint8* IeData() const; + + /** + * Stores the length of the IE(s) to be included into the (re-)association + * request. + * + * @since S60 3.2 + * @param aIeDataLength length of the IE(s) + */ + inline void IeDataLength( TUint16 aIeDataLength ); + + /** + * Returns the length of the IE(s) to be included into the (re-)association + * request. + * + * @since S60 3.2 + * @return length of the IE(s) + */ + inline TUint16 IeDataLength() const; + + /** + * Stores the Radio Measurement value to be included into the (re-)association + * request. + * + * @since S60 9.2 + * @param aRadioMeasurement True if Measurement on, otherwise false + */ + inline void RadioMeasurement( TBool aRadioMeasurement ); + + /** + * Returns the Radio Measurement value to be included into the (re-)association + * request. + * + * @since S60 9.2 + * @return Radio Measurement setting + */ + inline TBool RadioMeasurement() const; + + /** + * Sets desired privacy mode filter + * @param aEncryptionStatus desired privacy mode + */ + inline void SetActivePrivacyModeFilter( + WlanContextImpl& aCtxImpl, + TEncryptionStatus aEncryptionStatus ); + + /** + * Executes current privacy mode filter + * @param aFrameheader Header of the received frame + * @param aUserDataEnabled is protocol stack side datapath + * enabled or not + * @param aEthernetType Ethernet Type of the received frame + * @param aUnicastKeyExists AP <-> client unicast key + * is configured or not + * @param aAesOrTkipOrWapiEncrypted ETrue if the frame is encrypted with AES, + * TKIP or WAPI, EFalse otherwise + * @return ETrue if frame can be accepted, EFalse otherwise + */ + inline TBool ExecuteActivePrivacyModeFilter( + const SDataFrameHeader& aFrameheader, + TBool aUserDataEnabled, + TUint16 aEthernetType, + TBool aUnicastKeyExists, + TBool aAesOrTkipOrWapiEncrypted ) const; + + /** + * Gets capability information field + * @return capability information field + */ + inline SCapabilityInformationField& GetCapabilityInformation(); + + /** + * Resets BSS loss indication flags. + */ + inline void ResetBssLossIndications(); + + /** + * Gets AP advertised supported rates IE + * @return supported rates IE + */ + inline SSupportedRatesIE& GetApSupportedRatesIE(); + + /** + * Gets AP advertised extended supported rates IE + * @return extended supported rates IE + */ + inline SExtendedSupportedRatesIE& GetApExtendedSupportedRatesIE(); + + /** Resets Tx rate adaptation object */ + inline void ResetTxRateAdaptation(); + + /** + * Gets min basic rate of BSS + * @return min basic rate of BSS + */ + inline TUint32& GetMinBasicRate(); + + inline TUint32& GetMaxBasicRate(); + + inline void ClearBasicRateSet(); + inline void BasicRateSetBitSet( const TUint32 aRateBitToSet ); + inline TUint32 BasicRateSet() const; + + inline TBool WsaCmdActive() const; + inline void ActivateWsaCmd(); + inline void DeActivateWsaCmd(); + + /** + * Increments authentication sequnece expected counter + * to next expected sequence number + */ + inline void IncrementAuthSeqNmbrExpected(); + + /** + * Sets the rate adaptation object + */ + inline TBool SetTxRateAdaptationRates( + TUint8 aPolicyId, + WHA::TRate aRateBitmask ); + + /** + * Sets the Tx rate adaptation policy to be used with the specified Tx queue + * @param aQueueId id of the Tx queue + * @param aPolicyId id of the Tx rate policy + */ + inline void SetTxRatePolicy( WHA::TQueueId aQueueId, TUint8 aPolicyId ); + + /** + * Sets the current max Tx rate which should be initially used when sending + * frames using the specified Tx rate policy. + * If this rate is not present in the specified rate policy, or if + * it is not supported either by the nw or by WHA layer, the next possible + * lower rate will be used instead. + * However, if the specified rate is lower that any rate in the specified + * rate policy, the lowest rate in the policy will be used. + * + * @since S60 3.1 + * @param aPolicyId id of the Tx rate policy + * @param aRate initial max Tx rate + */ + inline void SetCurrentMaxTxRate( TUint8 aPolicyId, WHA::TRate aRate ); + + /** + * Sets the Tx rate adaptation algorithm parameters + * + * @since S60 3.1 + * @param aMinStepUpCheckpoint minimum and initial rate increase + * checkpoint in units of frames + * Range: [aStepDownCheckpoint,aMaxStepUpCheckpoint] + * @param aMaxStepUpCheckpoint maximum rate increase checkpoint in units + * of frames + * Range: [aStepDownCheckpoint,UCHAR_MAX] + * @param aStepUpCheckpointFactor StepUpCheckpoint is multiplied with this + * value if sending a probe frame fails + * Range: [1,aMaxStepUpCheckpoint] + * @param aStepDownCheckpoint after this many frames the need to decrease + * the rate is checked + * Range: [2,UCHAR_MAX] + * @param aMinStepUpThreshold minimum and initial StepUpThreshold + * percentage + * Range: [1,aMaxStepUpThreshold] + * @param aMaxStepUpThreshold maximum StepUpThreshold percentage + * Range: [1,100] + * @param aStepUpThresholdIncrement StepUpThreshold is incremented by this + * value if sending a probe frame fails + * Range: [0,aMaxStepUpThreshold] + * @param aStepDownThreshold if the percentage of frames which failed to + * be transmitted at the originally requested rate is at least + * aStepDownThreshold at the aStepDownCheckpoint, the rate will + * be decreased + * Range: [1,100] + * @param aDisableProbeHandling if EFalse, the rate adaptation algorithm + * handles the first frame transmitted after a rate increase in a + * special way. Otherwise the special handling is disabled + */ + inline void SetTxRateAdaptationAlgorithmParams( + TUint8 aMinStepUpCheckpoint, + TUint8 aMaxStepUpCheckpoint, + TUint8 aStepUpCheckpointFactor, + TUint8 aStepDownCheckpoint, + TUint8 aMinStepUpThreshold, + TUint8 aMaxStepUpThreshold, + TUint8 aStepUpThresholdIncrement, + TUint8 aStepDownThreshold, + TBool aDisableProbeHandling ); + + /** + * To be called when BSS Lost indication is received from WLAN PDD + * + * @since S60 5.0 + * @return ETrue if Consecutive Beacons Lost indication needs to be sent to + * WLAN Mgmt Client + * EFalse otherwise + */ + inline TBool OnConsecutiveBeaconsLost(); + + /** + * To be called after more than threshold number of consecutive Tx failures + * + * @since S60 5.0 + * @return ETrue if Consecutive Tx Failures indication needs to be sent to + * WLAN Mgmt Client + * EFalse otherwise + */ + inline TBool OnConsecutiveTxFailures(); + + /** + * To be called after more than threshold number of consecutive 802.11 Power + * Mgmt Mode setting failures + * + * @since S60 5.0 + * @return ETrue if Consecutive Power Mode Set Failures indication needs to + * be sent to WLAN Mgmt Client + * EFalse otherwise + */ + inline TBool OnConsecutivePwrModeSetFailures(); + + /** + * To be called when we have successfully communicated with the current AP + * + * @since S60 3.1 + * @return ETrue if BSS Regained indication needs to be sent to WLAN Mgmt + * Client + * EFalse otherwise + */ + TBool OnBssRegained(); + + /** + * Pushes a packet to the packet scheduler + * + * @since S60 3.1 + * @param aPacket the packet to transmit + * @param aLength length of the packet + * @param aQueueId id of the queue to use when sending the packet + * @param aPacketId frame type + * @param aMetaHeader frame meta header + * @param aMore ETrue if another frame is also ready to be transmitted + * EFalse otherwise + * @param aMulticastData ETrue if this is a multicast data frame + * @param aUseSpecialRatePolicy ETrue if use of the special Tx rate + * policy is requested for this frame Tx + * @return ETrue packet was accepted, EFalse otherwise + */ + inline TBool PushPacketToPacketScheduler( + const TAny* aPacket, + TUint32 aLength, + WHA::TQueueId aQueueId, + TUint32 aPacketId, + const TDataBuffer* aMetaHeader, + TBool aMore, + TBool aMulticastData, + TBool aUseSpecialRatePolicy = EFalse ); + + /** + * Removes all pending packet transmission entrys from + * the packet scheduler + * + * @since S60 3.1 + */ + inline void FlushPacketScheduler(); + + /** + * Schedules a packet and sends it if possible. + * If no packets to schedule exists does nothing + * If packet was send it is removed from the storage + * + * @since S60 3.1 + * @param aMore ETrue if another frame is also ready to be transmitted + * EFalse otherwise + */ + inline void SchedulePackets( TBool aMore ); + + /** + * Are there unsent Tx packets, i.e. packets not yet completed by WHA + * layer + * + * @since S60 3.2 + * @return ETrue if there are packets not yet completed by WHA layer + * EFalse otherwise + */ + inline TBool UnsentTxPackets() const; + + /** + * Increments the failed Tx packet counter + * + * @since S60 3.1 + */ + inline void IncrementFailedTxPacketCount(); + + /** + * Returns the value of failed Tx packet counter + * + * @since S60 3.1 + */ + inline TUint8 FailedTxPacketCount() const; + + /** + * Resets the failed Tx packet counter + * + * @since S60 3.1 + */ + inline void ResetFailedTxPacketCount(); + + /** + * Initializes the set power mgmt mode counter + * + * @since S60 3.1 + */ + inline void InitializeSetPsModeCount(); + + /** + * Decrements the set power mgmt mode counter by one + * + * @since S60 3.1 + */ + inline void DecrementSetPsModeCount(); + + /** + * Returns the value of the set power mgmt mode counter + * + * @since S60 3.1 + * @return Set power mgmt mode counter value + */ + inline TUint SetPsModeCount() const; + + /** + * Starts dynamic power mode management + * + * @since S60 3.1 + */ + inline void StartPowerModeManagement(); + + /** + * Stops dynamic power mode management + * + * @since S60 3.1 + */ + inline void StopPowerModeManagement(); + + /** + * To be called when transmitting a user data or WLAN Management Client frame + * + * Informs Dynamic Power Mode Manager about frame Tx. + * Determines the need to make a power mode transition. + * + * @since S60 3.1 + * @param aQueueId Id of the queue/AC via which the frame will be + * transmitted + * @param aEtherType Ethernet type of the frame + * @return To which power management mode to change; if any at all + */ + inline TPowerMgmtModeChange OnFrameTx( + WHA::TQueueId aQueueId, + TUint16 aEtherType ); + + /** + * To be called when accepting an Rx frame + * + * @since S60 3.1 + * @param aAccessCategory AC/Queue via which the frame has beeen transmitted + * @param aEtherType Ethernet type of the received frame + * @param aPayloadLength length of the ethernet frame payload + * @param aDaType DA type (Unicast, Multicast or Broadcast) of the frame + * @return To which power management mode to change; if any at all + */ + inline TPowerMgmtModeChange OnFrameRx( + WHA::TQueueId aAccessCategory, + TUint16 aEtherType, + TUint aPayloadLength, + TDaType aDaType ); + + /** + * Sets the dynamic power mode transition algorithm parameters + * + * @since S60 3.1 + * @param aCtxImpl statemachine context + * @param aToLightPsTimeout time interval in microseconds after which + * transition from Active mode to Light PS mode is considered + * @param aToLightPsFrameThreshold frame count threshold used when + * considering transition from Active to Light PS mode + * @param aToActiveTimeout time interval in microseconds after which the + * frame counter used when considering transition from Light PS + * to Active mode is reset + * @param aToActiveFrameThreshold frame count threshold used when + * considering transition from Light PS to Active mode + * @param aToDeepPsTimeout time interval in microseconds after which + * transition from Light PS mode to Deep PS mode is considered + * @param aToDeepPsFrameThreshold frame count threshold used when + * considering transition from Light PS to Deep PS mode + * @param aUapsdRxFrameLengthThreshold received frame + * payload length (in bytes) threshold in U-APSD network for + * Best Effort Access Category + * @return ETrue if a state change occurred + * EFalse otherwise + */ + inline void SetPowerModeManagementParameters( + TUint32 aToLightPsTimeout, + TUint16 aToLightPsFrameThreshold, + TUint32 aToActiveTimeout, + TUint16 aToActiveFrameThreshold, + TUint32 aToDeepPsTimeout, + TUint16 aToDeepPsFrameThreshold, + TUint16 aUapsdRxFrameLengthThreshold ); + + /** + * Configures dynamic power mode management traffic override + * + * The settings here become effective once using the PS mode has been + * allowed by WLAN Mgmt Client. + * When a setting below is ETrue, any amount of Rx or Tx traffic via + * the AC in question won't cause a change from PS to CAM mode once PS + * mode has been entered, and traffic via that AC won't make us to + * stay in CAM either. + * Every AC has a separate setting for U-APSD and legacy PS. + * The U-APSD setting is used if U-APSD is used for the AC in question. + * Otherwise the corresponding legacy setting is used. + * + * @since S60 3.2 + * @param aCtxImpl statemachine context + * @param aStayInPsDespiteUapsdVoiceTraffic U-APSD Voice AC setting + * @param aStayInPsDespiteUapsdVideoTraffic U-APSD Video AC setting + * @param aStayInPsDespiteUapsdBestEffortTraffic U-APSD Best Effort AC + * setting + * @param aStayInPsDespiteUapsdBackgroundTraffic U-APSD Background AC + * setting + * @param aStayInPsDespiteLegacyVoiceTraffic legacy Voice AC setting + * @param aStayInPsDespiteLegacyVideoTraffic legacy Video AC setting + * @param aStayInPsDespiteLegacyBestEffortTraffic legacy Best Effort AC + * setting + * @param aStayInPsDespiteLegacyBackgroundTraffic legacy Background AC + * setting + * @return ETrue if a state change occurred + * EFalse otherwise + */ + inline void ConfigurePwrModeMgmtTrafficOverride( + TBool aStayInPsDespiteUapsdVoiceTraffic, + TBool aStayInPsDespiteUapsdVideoTraffic, + TBool aStayInPsDespiteUapsdBestEffortTraffic, + TBool aStayInPsDespiteUapsdBackgroundTraffic, + TBool aStayInPsDespiteLegacyVoiceTraffic, + TBool aStayInPsDespiteLegacyVideoTraffic, + TBool aStayInPsDespiteLegacyBestEffortTraffic, + TBool aStayInPsDespiteLegacyBackgroundTraffic ); + + /** + * Freezes the dynamic power mode management traffic override settings + * provided earlier with the ConfigurePwrModeMgmtTrafficOverride() method + * and based on whether U-APSD is used for the different ACs/Tx queues + * + * @since S60 3.2 + */ + inline void FreezePwrModeMgmtTrafficOverride(); + + /** + * To be called upon Active to Light PS timer timeout + * + * @since S60 v5.1 + * @return ETrue if power mode transition should be done, + * EFalse otherwise + */ + inline TBool OnActiveToLightPsTimerTimeout(); + + /** + * To be called upon Light PS to Active timer timeout + * + * @since S60 v5.1 + * @return ETrue if power mode transition should be done, + * EFalse otherwise + */ + inline TBool OnLightPsToActiveTimerTimeout(); + + /** + * To be called upon Light PS to Deep PS timer timeout + * + * @since S60 v5.1 + * @return ETrue if power mode transition should be done, + * EFalse otherwise + */ + inline TBool OnLightPsToDeepPsTimerTimeout(); + + /** + * Adds a multicast (Rx) address to our internal bookkeeping. + * @param aMacAddress Address to be added + * @return See TGroupAddStatus definition. + */ + inline TGroupAddStatus AddMulticastAddress( + const TMacAddress& aMacAddress ); + + /** + * Removes a multicast (Rx) address from our internal bookkeeping. + * @param aMacAddress MAC address to be removed + * @return ETrue if address was found (and hence removed) + * EFalse otherwise + */ + inline TBool RemoveMulticastAddress( const TMacAddress& aMacAddress ); + + /** + * Returns the number of multicast (Rx) addresses that exist in our + * internal bookkeeping currently + * @return Address count + */ + inline TUint8 MulticastAddressCount() const; + + /** + * Gets all the multicast (Rx) addresses from our internal bookkeeping + * by passing back a pointer to the 1st address which is followed by + * all the other addresses. + * @return The number of addresses returned. + */ + inline TUint8 GetMulticastAddresses( + const TMacAddress*& aMacAddresses ) const; + + /** + * Clears our internal multicast (Rx) address bookkeeping by removing + * all addresses. + */ + inline void ResetMulticastAddresses(); + + inline void MarkInternalTxBufFree(); + + inline TBool InternalTxBufBeingWaited() const; + + inline void ClearInternalTxBufBeingWaitedFlag(); + + /** + * Resets frame statistics + * + * @since S60 3.2 + */ + inline void ResetFrameStatistics(); + + /** + * Increments Rx unicast data frame count by one + * + * @since S60 3.2 + * @param aAccessCategory AC/Queue via which the frame was transmitted + */ + inline void IncrementRxUnicastDataFrameCount( + WHA::TQueueId aAccessCategory ); + + /** + * Increments Tx unicast data frame count by one + * + * @since S60 3.2 + * @param aAccessCategory AC/Queue via which the frame was transmitted + */ + inline void IncrementTxUnicastDataFrameCount( + WHA::TQueueId aAccessCategory ); + + /** + * Increments Rx multicast data frame count by one + * + * @since S60 3.2 + * @param aAccessCategory AC/Queue via which the frame was transmitted + */ + inline void IncrementRxMulticastDataFrameCount( + WHA::TQueueId aAccessCategory ); + + /** + * Increments Tx multicast data frame count by one + * + * @since S60 3.2 + * @param aAccessCategory AC/Queue via which the frame was transmitted + */ + inline void IncrementTxMulticastDataFrameCount( + WHA::TQueueId aAccessCategory ); + + /** + * Increments Tx frame retry count by aCount + * + * @since S60 3.2 + * @param aAccessCategory AC/Queue via which the frame was transmitted + * @param aCount number to add to the current count + */ + inline void IncrementTxRetryCount( + WHA::TQueueId aAccessCategory, + TUint aCount ); + + /** + * Increments Tx error count by one + * + * @since S60 3.2 + * @param aAccessCategory AC/Queue via which the frame was transmitted + */ + inline void IncrementTxErrorCount(WHA::TQueueId aAccessCategory ); + + /** + * Increments cumulative Tx Media Delay by aDelay + * + * @since S60 3.2 + * @param aAccessCategory AC/Queue via which the frame was transmitted + * @param aDelay Amount of delay to add to the current cumulative delay + */ + inline void IncrementTxMediaDelay( + WHA::TQueueId aAccessCategory, + TUint aDelay ); + + /** + * Returns the average Tx Media Delay of the specified Access Category + * + * Note! When this method is called the txMediaDelay field shall contain + * the cumulative Tx Media Delay. + * + * @since S60 3.2 + * @param aAccessCategory AC/Queue for which the average is requested + * @return Average Tx Media Delay + */ + TUint AverageTxMediaDelay( WHA::TQueueId aAccessCategory ) const; + + /** + * Calculates the average Tx Media Delay for all Access Categories + * and stores the results into frame statistics results + * + * @since S60 3.2 + */ + void CalculateAverageTxMediaDelays(); + + /** + * Increments cumulative Total Tx Delay by aDelay + * + * @since S60 3.2 + * @param aAccessCategory AC/Queue via which the frame was transmitted + * @param aDelay Amount of delay to add to the current cumulative delay + */ + inline void IncrementTotalTxDelay( + WHA::TQueueId aAccessCategory, + TUint aDelay ); + + /** + * Updates Total Tx Delay histogram + * + * @since S60 3.2 + * @param aAccessCategory AC/Queue via which the frame was transmitted + * @param aDelay Total Tx Delay of the frame + */ + void UpdateTotalTxDelayHistogram( + WHA::TQueueId aAccessCategory, + TUint aDelay ); + + /** + * Returns the average Total Tx Delay of the specified Access Category + * + * Note! When this method is called the totalTxDelay field shall contain + * the cumulative Total Tx Delay. + + * @since S60 3.2 + * @param aAccessCategory AC/Queue for which the average is requested + * @return Average Total Tx Delay + */ + TUint AverageTotalTxDelay( WHA::TQueueId aAccessCategory ) const; + + /** + * Calculates the average Total Tx Delay for all Access Categories + * and stores the results into frame statistics results + * + * @since S60 3.2 + */ + void CalculateAverageTotalTxDelays(); + + /** + * Stores FCS error count recorded in received MPDUs + * + * @since S60 3.2 + * @param aCount the value to set + */ + inline void StoreFcsErrorCount( TUint aCount ); + + /** + * Returns frame statistics + * + * @since S60 3.2 + * @return reference to frame statistics + */ + inline const TStatisticsResponse& FrameStatistics() const; + + /** + * Sets Null Frame Send Controller parameters + * + * @since S60 3.2 + * @param aVoiceCallEntryTimeout when we are not in Voice over WLAN Call + * state and we transmit at least aVoiceCallEntryTxThreshold + * Voice priority frames during the time period (microseconds) + * denoted by this parameter, we enter Voice over WLAN Call state + * @param aVoiceCallEntryTxThreshold Threshold value for the number of + * Voice priority Tx frames to enter Voice over WLAN Call state + * @param aNullTimeout NULL frame sending interval + * @param aNoVoiceTimeout after this long time of no Voice priority data + * Tx, exit voice call state + * @param aKeepAliveTimeout Keep Alive frame sending interval in + * infrastructure mode + */ + inline void SetNullSendControllerParameters( + TUint32 aVoiceCallEntryTimeout, + TUint32 aVoiceCallEntryTxThreshold, + TUint32 aNullTimeout, + TUint32 aNoVoiceTimeout, + TUint32 aKeepAliveTimeout ); + + /** + * Starts Voice over WLAN Call maintenance + * + * @since S60 3.2 + */ + inline void StartVoiceOverWlanCallMaintenance(); + + /** + * Stops Voice over WLAN Call maintenance + * + * @since S60 3.2 + */ + inline void StopVoiceOverWlanCallMaintenance(); + + /** + * Terminates Voice over WLAN Call maintenance + */ + inline void TerminateVoiceOverWlanCallMaintenance(); + + /** + * Resumes QoS null frame sending, if relevant. + * Doesn't change the Voice over WLAN Call state + * + * @since S60 3.2 + */ + inline void ResumeQosNullSending(); + + /** + * Starts Keep Alive frame sending + * + * @since S60 3.2 + */ + inline void StartKeepAlive(); + + /** + * Stops Keep Alive frame sending + * + * @since S60 3.2 + */ + inline void StopKeepAlive(); + + /** + * To be called upon every RX Data frame (other than Null and QoS Null Data) + * + * @since S60 3.2 + * @param aQueueId Id of the queue/AC via which the frame will be transmitted + * @param aPayloadLength length of the ethernet frame payload + */ + inline void OnDataRxCompleted( + WHA::TQueueId aQueueId, + TUint aPayloadLength ); + + /** + * To be called upon every Data frame (other than Null and QoS Null Data) + * send completion + * + * @since S60 3.2 + * @param aQueueId Id of the queue/AC via which the frame will be transmitted + */ + inline void OnDataTxCompleted( WHA::TQueueId aQueueId ); + + /** + * To be called upon every QoS Null Data frame send completion + * + * @since S60 3.2 + */ + inline void OnQosNullDataTxCompleted(); + + /** + * To be called upon every Null Data frame send completion + * + * @since S60 3.2 + */ + inline void OnNullDataTxCompleted(); + + /** + * To be called upon Voice Call Entry Timer timeout + * + * @since S60 3.2 + */ + inline void OnVoiceCallEntryTimerTimeout(); + + /** + * To be called upon Null Timer timeout + * + * @since S60 3.2 + */ + inline void OnNullTimerTimeout(); + + /** + * To be called upon Voice Timer timeout + * + * @since S60 3.2 + */ + inline void OnNoVoiceTimerTimeout(); + + /** + * To be called upon Keep Alive Timer timeout + * + * @since S60 3.2 + */ + void OnKeepAliveTimerTimeout(); + + /** + * Insert new RCPI value into the Signal Predictor. + * + * @since S60 3.2 + * @param aTimestamp Current time (in microseconds) + * @param aRcpi RCPI value from HW + * @return ETrue if an indication about weakening signal should be created + * EFalse otherwise + */ + inline TBool InsertNewRcpiIntoPredictor( TInt64 aTimestamp, WHA::TRcpi aRcpi ); + + /** + * Gets the latest median RCPI value from Signal Predictor. + * + * @since S60 v3.2 + * @param aTimestamp Current time (in microseconds). + * @param aLatestMedian reference to the median. + * @return ETrue if median RCPI value is available. + * EFalse otherwise + */ + inline TBool GetLatestMedianRcpiFromPredictor( + TInt64 aTimestamp, + WHA::TRcpi& aLatestMedian ) const; + + /** + * Configures the Signal Predictor. + * + * @since S60 v5.0 + * @param aTimeToWarnLevel Specifies the time (in microseconds) + * how far into the future signal prediction is done. + * @param aTimeToNextInd The minimum time difference (in + * microseconds) between two signal loss prediction indications. + * @param aRcpiWarnLevel If this RCPI level is predicted to be + * reached within the time specified by aSpTimeToCountPrediction, + * a signal loss prediction indication is sent. + */ + inline void ConfigureWlanSignalPredictor( + TUint32 aTimeToWarnLevel, + TUint32 aTimeToNextInd, + WHA::TRcpi aRcpiWarnLevel ); + + /** + * Adds a WLAN feature supported by us to the list of those supported + * features which are indicated in BSS membership selector + * + * @param aFeature Feature to add + */ + void AddBssMembershipFeature( T802Dot11BssMembershipSelector aFeature ); + + /** + * Checks if the specified item is a WLAN feature indicated in BSS + * membership selector and if it is supported by us + * + * @param aItem Item to check + * @return ETrue if supported + * EFalse otherwise + */ + TBool BssMembershipFeatureSupported( TUint8 aItem ) const; + + /** + * Gets our HT Capabilities element + * @return HT Capabilities element + */ + inline SHtCapabilitiesIE& GetOurHtCapabilitiesIe(); + + /** + * Gets target/current network's HT Capabilities element + * @return HT Capabilities element + */ + inline SHtCapabilitiesIE& GetNwHtCapabilitiesIe(); + + /** + * Gets target/current network's HT Operation element + * @return HT Operation element + */ + inline SHtOperationIE& GetNwHtOperationIe(); + + /** + * Gets HT Block Ack configuration provided by WLAN Mgmt client + * @return HT Block Ack configuration + */ + inline WHA::ShtBlockAckConfigure& GetHtBlockAckConfigure(); + + /** + * Gets proprietary SNAP header provided by WLAN Mgmt client + * @return Proprieatary SNAP header + */ + inline SSnapHeader& GetProprietarySnapHeader(); + + /** + * Gets WHA layer transmission status + * + * @param aTxQueueState State (full / not full) of every WHA transmit queue + * @return ETrue if the Tx pipeline is active, i.e. Tx frame submission + * is allowed + * EFalse if the Tx pipeline is not active, i.e. Tx frame submission + * is not allowed + */ + inline TBool GetWhaTxStatus( TWhaTxQueueState& aTxQueueState ) const; + +protected: + + /** + * Method called when packet has been transferred to the WLAN device + * + * @since S60 3.1 + * @param aCtxImpl global state machine context + * @param aPacketId packet whose transfer is complete + * @param aMetaHeader frame meta header + */ + virtual void OnPacketTransferComplete( + WlanContextImpl& aCtxImpl, + TUint32 aPacketId, + TDataBuffer* aMetaHeader ); + + virtual void OnPacketSendComplete( + WlanContextImpl& aCtxImpl, + WHA::TStatus aStatus, + TUint32 aPacketId, + WHA::TRate aRate, + TUint32 aPacketQueueDelay, + TUint32 aMediaDelay, + TUint aTotalTxDelay, + TUint8 aAckFailures, + WHA::TQueueId aQueueId, + WHA::TRate aRequestedRate, + TBool aMulticastData ); + + /** + * Method called when packet has been flushed (removed) + * from packet scheduler + * + * @since S60 3.1 + * @param aCtxImpl global state machine context + * @param aPacketId packet that was flushed + * @param aMetaHeader frame meta header + */ + virtual void OnPacketFlushEvent( + WlanContextImpl& aCtxImpl, + TUint32 aPacketId, + TDataBuffer* aMetaHeader ); + + /** + * Method called when Packet Scheduler's packet scheduling method + * should be called, as there exists a packet that is suitable for + * transmission. + * NOTE: if any other Packet Scheduler method is called within this + * context the result is undefined. + * + * @param aCtxImpl global state machine context + * @param aMore ETrue if another frame is also ready to be transmitted + * EFalse otherwise + */ + virtual void CallPacketSchedule( + WlanContextImpl& aCtxImpl, + TBool aMore ); + + virtual void OnPacketPushPossible( WlanContextImpl& aCtxImpl ); + + virtual void CommandResponse( + WHA::TCommandId aCommandId, + WHA::TStatus aStatus, + const WHA::UCommandResponseParams& aCommandResponseParams ); + + virtual void CommandComplete( + WHA::TCompleteCommandId aCompleteCommandId, + WHA::TStatus aStatus, + const WHA::UCommandCompletionParams& aCommandCompletionParams ); + + virtual void Indication( + WHA::TIndicationId aIndicationId, + const WHA::UIndicationParams& aIndicationParams ); + + // Frame sending callbacks + + virtual void SendPacketTransfer( + WHA::TPacketId aPacketId ); + + virtual void SendPacketComplete( + WHA::TStatus aStatus, + WHA::TPacketId aPacketId, + WHA::TRate aRate, + TUint32 aPacketQueueDelay, + TUint32 aMediaDelay, + TUint8 aAckFailures, + TUint16 aSequenceNumber ); + + + // Frame receive + + virtual TAny* RequestForBuffer( TUint16 aLength ); + + virtual void ReceivePacket( + WHA::TStatus aStatus, + const void* aFrame, + TUint16 aLength, + WHA::TRate aRate, + WHA::TRcpi aRcpi, + WHA::TChannelNumber aChannel, + void* aBuffer, + TUint32 aFlags ); + + /** + * Request to send a Null Data Frame + * + * @since S60 v3.2 + * @param aCtxImpl statemachine context + * @param aQosNull ETrue if a QoS Null Data frame should be transmitted + * EFalse if a regular Null Data frame should be transmitted + * @return ETrue if the send request was successfully submitted + * EFalse otherwise + */ + virtual TBool TxNullDataFrame( + WlanContextImpl& aCtxImpl, + TBool aQosNull ); + + // Prohibit copy constructor + WlanContextImpl( const WlanContextImpl& aCntx ); + // Prohibit assigment operator + WlanContextImpl& operator= ( const WlanContextImpl& ); + +public: // data + + WlanMacState* iCurrentMacState; + Umac& iUmac; + + + /** The states of the statemachine */ + States iStates; + /** 802.11 MIB */ + SWlanMib iWlanMib; + /** supported rates lookup table */ + SupportedRateLookUp + iSupportedRatesLookUpTable[KMaxNumberOfDot11bAndgRates]; + /** is protocol stack side datapath enabled or not */ + TBool iEnableUserData; + + TUint8* iCurrentRxBuffer; + +private: // definitions + + /** + * max number of features in our WLAN feature array (see below) + */ + static const TUint KMaxNumOfWlanFeatures = 1; + + /** + * value used in WLAN feature array for unallocated elements + */ + static const TUint8 KUnallocated = 0; + + /** + * container type for IDs of those WLAN features which are indicated in BSS + * membership selector + */ + typedef TUint8 TWlanFeatureArray[KMaxNumOfWlanFeatures]; + +private: // data + + /** + * ETrue if the Tx data buffer for frames created internally in this + * component is free (applies both to the DMA and the non-DMA Tx buffer). + * EFalse if it is in use + */ + TBool iInternalTxBufFree; + + /** + * ETrue if someone if waiting for the internal Tx Buffer to become + * available. EFalse othwerwise + */ + TBool iInternalTxBufBeingWaited; + + TWlanUserTxDataCntx iTxDataCntx; + TWlanUserTxDataCntx iMgmtTxDataCntx; + + /** data frame header template */ + SDataFrameHeader iDataFrameHeader; + + TUint32 iAlignNullData; + SNullDataFrame iNullDataFrame; + + TUint32 iAlignQosNullData; + SHtQosNullDataFrame iQosNullDataFrame; + + /** authentication sequence expected counter */ + WlanAuthSeqNmbrExpected iAuthSeqNmbrExpected; + /** connection state info */ + + WlanConnectContext iConnectContext; + /** available privacy mode filters */ + WlanPrivacyModeFilters iPrivacyModeFilters; + /** + * container for joined multicast (Rx) groups. Contains the + * multicast MAC addresses denoting the groups. + */ + JoinedMulticastGroups iJoinedMulticastGroups; + /** + * has Consecutive Beacons Lost indication already been sent to + * WLAN Mgmt Client + */ + TBool iConsecutiveBeaconsLostIndicated; + /** + * has Consecutive Tx Failures indication already been sent to + * WLAN Mgmt Client + */ + TBool iConsecutiveTxFailuresIndicated; + /** + * has Consecutive 802.11 Power Mgmt Mode Set Failures indication already + * been sent to WLAN Mgmt Client + */ + TBool iConsecutivePwrModeSetFailuresIndicated; + /** + * failed Tx packet counter used to determine if we should indicate + * Consecutive Tx Failures + */ + TUint8 iFailedTxPacketCount; + /** + * counter which states how many times we will still try to change the + * 802.11 power management mode before indicating Consecutive 802.11 + * Power Mgmt Mode Set Failures, if we continue to be unsuccessful in + * the power management mode changing + */ + TUint iSetPsModeCount; + + /** is a WHA cmd active */ + TBool iWsaCmdActive; + + WlanTxRateAdaptation iTxRateAdaptation; + + WlanPRNGenerator iPrnGenerator; + + // Asynchronous Completion Token for WHA command + TUint32 iWhaCommandAct; + + /** 802.11 management frame templates */ + ManagementFrameTemplates iManagementFrameTemplates; + + WHA::Wha* iWha; + WHA::SSettings iWHASettings; + + SWsaCommands* iWsaCommands; + + WlanEventDispatcher iEventDispatcher; + WlanPacketScheduler iPacketScheduler; + /** dynamic power mode context */ + WlanDynamicPowerModeMgmtCntx iDynamicPowerModeCntx; + + /** frame statistics counters */ + TStatisticsResponse iFrameStatistics; + + /** Null Data Frame sending controller */ + WlanNullSendController iNullSendController; + + /** WLAN signal predictor */ + WlanSignalPredictor iWlanSignalPredictor; + + /** + * includes IDs of those WLAN features which are indicated in BSS membership + * selector and which we support + */ + TWlanFeatureArray iOurBssMembershipFeatureArray; + + /** + * HT Capabilities element which we use to inform about our static HT + * capabilities + */ + SHtCapabilitiesIE iOurHtCapabilitiesIe; + + /** HT Block Ack configuration provided by WLAN Mgmt Client */ + WHA::ShtBlockAckConfigure iHtBlockAckConfigure; + + /** + * Otherwise valid received 802.11 Data frames containing this SNAP header + * are accepted and forwarded to the WLAN Management Client. + */ + SSnapHeader iProprietarySnapHeader; + }; + +#include "UmacContextImpl.inl" + +#endif // WLANCONTEXTIMPL_H