--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/wlan_bearer/wlanldd/wlan_common/umac_common/src/UmacDot11Synchronize.cpp Tue Feb 02 02:03:13 2010 +0200
@@ -0,0 +1,833 @@
+/*
+* 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: Implementation of the UmacDot11Synchronize class
+*
+*/
+
+/*
+* %version: 28 %
+*/
+
+#include "config.h"
+#include "UmacDot11Synchronize.h"
+#include "UmacContextImpl.h"
+#include "UmacWsaWriteMib.h"
+#include "UmacWsaJoin.h"
+#include "umacconfiguretxqueueparams.h"
+#include "wha_mibDefaultvalues.h"
+
+#ifndef NDEBUG
+const TInt8 WlanDot11Synchronize::iName[] = "dot11-synchronize";
+
+const TUint8 WlanDot11Synchronize::iStateName
+ [ESTATEMAX][KMaxStateStringLength] =
+ {
+ {"EINIT"},
+ {"ESETDOT11SLOTTIME"},
+ {"ESETCTSTOSELF"},
+ {"ECONFTXQUEUE"},
+ {"ECONFTXQUEUEPARAMS"},
+ {"ESETTXRATEPOLICY"},
+ {"ESETHTCAPABILITIES"},
+ {"ESETHTBSSOPERATION"},
+ {"ERESETHTCAPABILITIES"},
+ {"EISSUEJOIN"},
+ {"ESETHTBLOCKACKCONF"},
+ {"ERESETHTBLOCKACKCONF"},
+ {"ECONTINUEDOT11TRAVERSE"}
+ };
+
+const TUint8 WlanDot11Synchronize::iEventName
+ [EEVENTMAX][KMaxEventStringLength] =
+ {
+ {"ESTATEENTRY"},
+ {"ETXCOMPLETE"},
+ {"EABORT"}
+ };
+#endif
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+WlanDot11Synchronize::WlanDot11Synchronize() :
+ iState( EINIT ), iJoinFailed ( EFalse )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+WlanDot11Synchronize::~WlanDot11Synchronize()
+ {
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+#ifndef NDEBUG
+const TInt8* WlanDot11Synchronize::GetStateName( TUint8& aLength ) const
+ {
+ aLength = sizeof( iName );
+ return iName;
+ }
+#endif
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::Entry( WlanContextImpl& aCtxImpl )
+ {
+ if ( aCtxImpl.WsaCmdActive() )
+ {
+ // sanity checking code
+ OsAssert( (TUint8*)("UMAC * panic"),
+ (TUint8*)(WLAN_FILE), __LINE__ );
+ }
+
+ // don't want to do event dispatching here as we want
+ // to run this dot11 state critter in non pre-emptive mode
+
+ if ( iState != EINIT )
+ {
+ // this is NOT the start of the the FSM actions
+ // note that we send the ETXCOMPLETE event as the states
+ // that wait for it are the only ones that can be interrupted
+ // as they are asynchronous operations by nature
+ // and wait for corresponding WHA completion method
+ Fsm( aCtxImpl, ETXCOMPLETE );
+ }
+ else
+ {
+ // this is the start of the the FSM actions
+ Fsm( aCtxImpl, ESTATEENTRY );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::Exit( WlanContextImpl& /*aCtxImpl*/ )
+ {
+ OsTracePrint(
+ KUmacProtocolState,
+ (TUint8*)("UMAC: WlanDot11Synchronize::Exit()"));
+
+ // we are departing this dot11state to another dot11state, so
+ // we simple reset our local FSM for the next time...
+ iState = EINIT;
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::Fsm(
+ WlanContextImpl& aCtxImpl,
+ TEvent aEvent )
+ {
+#ifndef NDEBUG
+ OsTracePrint( KUmacDetails, (TUint8*)("UMAC: WlanDot11Synchronize::Fsm(): event: "));
+ OsTracePrint( KUmacDetails, iEventName[aEvent] );
+ OsTracePrint( KUmacDetails, (TUint8*)("UMAC: WlanDot11Synchronize::Fsm(): state: "));
+ OsTracePrint( KUmacDetails, iStateName[iState] );
+#endif
+
+ switch ( aEvent )
+ {
+ case ESTATEENTRY:
+ OnStateEntryEvent( aCtxImpl );
+ break;
+ case ETXCOMPLETE:
+ OnTxCompleteEvent( aCtxImpl );
+ break;
+ default:
+ OsTracePrint(
+ KErrorLevel,
+ (TUint8*)("UMAC: WlanDot11Synchronize::Fsm(): event: %d"),
+ aEvent);
+ OsAssert(
+ (TUint8*)("UMAC: WlanDot11Synchronize::Fsm(): panic"),
+ (TUint8*)(WLAN_FILE), __LINE__ );
+ break;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// Handler for state entry event.
+// -----------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::OnStateEntryEvent(
+ WlanContextImpl& aCtxImpl )
+ {
+ OsTracePrint(
+ KUmacDetails,
+ (TUint8*)("UMAC: WlanDot11Synchronize::OnStateEntryEvent()"));
+
+ switch ( iState )
+ {
+ case EINIT:
+ if ( InitActions( aCtxImpl ) )
+ {
+ // we meet the requirements of the network so we can continue
+
+ // depending if the WLAN vendor specific solution
+ // implements dot11slottime mib we will configure it
+ if ( aCtxImpl.WHASettings().iCapability
+ & WHA::SSettings::KDot11SlotTime )
+ {
+ // supported
+ ChangeInternalState( aCtxImpl, ESETDOT11SLOTTIME );
+ }
+ else
+ {
+ // not supported so skip it
+ OsTracePrint( KWarningLevel, (TUint8*)
+ ("UMAC * dot11-synchronize"));
+ OsTracePrint( KWarningLevel, (TUint8*)
+ ("no support for dot11slottime mib skipping"));
+
+ ChangeInternalState( aCtxImpl, ESETCTSTOSELF );
+ }
+ }
+ else
+ {
+ // network requirements not met. Take the same action as
+ // as in the join failed case
+
+ OsTracePrint(
+ KWarningLevel, (TUint8*)
+ ("UMAC: WlanDot11Synchronize::OnStateEntryEvent(): network requirements not met - abort"));
+
+ iJoinFailed = ETrue;
+ ChangeInternalState( aCtxImpl, ECONTINUEDOT11TRAVERSE );
+ }
+ break;
+ case ESETDOT11SLOTTIME:
+ SetDot11SlotTime( aCtxImpl );
+ break;
+ case ESETCTSTOSELF:
+ SetCtsToSelf( aCtxImpl );
+ break;
+ case ECONFTXQUEUE:
+ ConfigureQueue( aCtxImpl );
+ break;
+ case ECONFTXQUEUEPARAMS:
+ ConfigureTxQueueParams( aCtxImpl );
+ break;
+ case ESETTXRATEPOLICY:
+ SetTxRatePolicy( aCtxImpl );
+ break;
+ case ESETHTCAPABILITIES:
+ SetHtCapabilities( aCtxImpl );
+ break;
+ case ESETHTBSSOPERATION:
+ SetHtBssOperation( aCtxImpl );
+ break;
+ case ERESETHTCAPABILITIES:
+ ResetHtCapabilities( aCtxImpl );
+ break;
+ case EISSUEJOIN:
+ IssueJoin( aCtxImpl );
+ break;
+ case ESETHTBLOCKACKCONF:
+ SetHtBlockAckConfiguration( aCtxImpl );
+ break;
+ case ERESETHTBLOCKACKCONF:
+ ResetHtBlockAckConfiguration( aCtxImpl );
+ break;
+ case ECONTINUEDOT11TRAVERSE:
+ ContinueDot11StateTraversal( aCtxImpl );
+ break;
+ default:
+ // programming error
+ OsTracePrint(
+ KErrorLevel,
+ (TUint8*)("UMAC: WlanDot11Synchronize::OnStateEntryEvent(): state: %d"),
+ iState);
+ OsAssert( (TUint8*)("UMAC: WlanDot11Synchronize::OnStateEntryEvent(): panic"),
+ (TUint8*)(WLAN_FILE), __LINE__ );
+ break;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::OnTxCompleteEvent(
+ WlanContextImpl& aCtxImpl )
+ {
+ OsTracePrint(
+ KUmacDetails,
+ (TUint8*)("UMAC: WlanDot11Synchronize::OnTxCompleteEvent()"));
+
+ switch ( iState )
+ {
+ case ESETDOT11SLOTTIME:
+ // continue state traversal
+ ChangeInternalState( aCtxImpl, ESETCTSTOSELF );
+ break;
+ case ESETCTSTOSELF:
+ if ( aCtxImpl.QosEnabled() )
+ {
+ // configure all the Tx queues & their AC parameters
+ ChangeInternalState( aCtxImpl, ECONFTXQUEUEPARAMS );
+ }
+ else
+ {
+ // configure just the legacy Tx queue
+ ChangeInternalState( aCtxImpl, ECONFTXQUEUE );
+ }
+ break;
+ case ECONFTXQUEUE:
+ case ECONFTXQUEUEPARAMS:
+ ChangeInternalState( aCtxImpl, ESETTXRATEPOLICY );
+ break;
+ case ESETTXRATEPOLICY:
+ if ( aCtxImpl.HtSupportedByNw() )
+ {
+ ChangeInternalState( aCtxImpl, ESETHTCAPABILITIES );
+ }
+ else
+ {
+ if ( aCtxImpl.WHASettings().iCapability &
+ WHA::SSettings::KHtOperation )
+ {
+ ChangeInternalState( aCtxImpl, ERESETHTCAPABILITIES );
+ }
+ else
+ {
+ ChangeInternalState( aCtxImpl, EISSUEJOIN );
+ }
+ }
+ break;
+ case ESETHTCAPABILITIES:
+ ChangeInternalState( aCtxImpl, ESETHTBSSOPERATION );
+ break;
+ case ESETHTBSSOPERATION:
+ ChangeInternalState( aCtxImpl, EISSUEJOIN );
+ break;
+ case ERESETHTCAPABILITIES:
+ ChangeInternalState( aCtxImpl, EISSUEJOIN );
+ break;
+ case EISSUEJOIN:
+ if ( aCtxImpl.HtSupportedByNw() )
+ {
+ ChangeInternalState( aCtxImpl, ESETHTBLOCKACKCONF );
+ }
+ else
+ {
+ if ( aCtxImpl.WHASettings().iCapability &
+ WHA::SSettings::KHtOperation )
+ {
+ ChangeInternalState( aCtxImpl, ERESETHTBLOCKACKCONF );
+ }
+ else
+ {
+ ChangeInternalState( aCtxImpl, ECONTINUEDOT11TRAVERSE );
+ }
+ }
+ break;
+ case ESETHTBLOCKACKCONF:
+ ChangeInternalState( aCtxImpl, ECONTINUEDOT11TRAVERSE );
+ break;
+ case ERESETHTBLOCKACKCONF:
+ ChangeInternalState( aCtxImpl, ECONTINUEDOT11TRAVERSE );
+ break;
+ default:
+ // catch internal FSM programming error
+ OsAssert(
+ (TUint8*)("UMAC: WlanDot11Synchronize::OnTxCompleteEvent(): panic"),
+ (TUint8*)(WLAN_FILE), __LINE__ );
+ break;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// as there's really nothing else we can do in this situation,
+// simulate macNotResponding error
+// -----------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::OnAbortEvent(
+ WlanContextImpl& aCtxImpl )
+ {
+ OsTracePrint( KWarningLevel,
+ (TUint8*)("UMAC * dot11-synchronize * abort") );
+
+ DoErrorIndication( aCtxImpl, WHA::KErrorMacNotResponding );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::ContinueDot11StateTraversal(
+ WlanContextImpl& aCtxImpl )
+ {
+ OsTracePrint(
+ KUmacDetails,
+ (TUint8*)("UMAC: WlanDot11Synchronize::ContinueDot11StateTraversal()"));
+
+ if ( iJoinFailed )
+ {
+ // set the completion code value to be returned to user mode
+ // as the dot11idle state does the OID completion in this case
+ aCtxImpl.iStates.iIdleState.Set( KErrGeneral );
+ // ... and proceed to dot11idle state
+ ChangeState( aCtxImpl,
+ *this, // prev state
+ aCtxImpl.iStates.iIdleState // next state
+ );
+ }
+ else
+ {
+ if ( aCtxImpl.AuthenticationAlgorithmNumber() !=
+ K802Dot11AuthModeShared )
+ {
+ // proceed with open authentication
+ ChangeState( aCtxImpl,
+ *this, // prev state
+ aCtxImpl.iStates.iOpenAuthPendingState // next state
+ );
+ }
+ else
+ {
+ // proceed with shared authentication
+ ChangeState( aCtxImpl,
+ *this, // prev state
+ aCtxImpl.iStates.iSharedAuthPending // next state
+ );
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::ChangeInternalState(
+ WlanContextImpl& aCtxImpl,
+ TState aNewState )
+ {
+#ifndef NDEBUG
+ OsTracePrint(
+ KUmacDetails,
+ (TUint8*)("UMAC: WlanDot11Synchronize::ChangeInternalState(): old state:"));
+ OsTracePrint( KUmacDetails, iStateName[iState] );
+ OsTracePrint(
+ KUmacDetails,
+ (TUint8*)("UMAC: WlanDot11Synchronize::ChangeInternalState(): new state:"));
+ OsTracePrint( KUmacDetails, iStateName[aNewState] );
+#endif
+
+ iState = aNewState;
+ Fsm( aCtxImpl, ESTATEENTRY );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+TBool WlanDot11Synchronize::InitActions( WlanContextImpl& aCtxImpl )
+ {
+ OsTracePrint(
+ KUmacDetails,
+ (TUint8*)("UMAC: WlanDot11Synchronize::InitActions()"));
+
+ // as we are about to join a new AP, reset BSS Loss indicators
+ aCtxImpl.ResetBssLossIndications();
+
+ iJoinFailed = EFalse;
+ // reset counter for this new AP connection
+ aCtxImpl.ResetFailedTxPacketCount();
+
+ os_memset(
+ reinterpret_cast<TUint8*>(&(aCtxImpl.GetNwHtCapabilitiesIe().iData)),
+ 0,
+ K802Dot11HtCapabilitiesIeDataLen );
+
+ for ( TUint i = 0; i < WHA::EQueueIdMax; ++i )
+ {
+ aCtxImpl.iWlanMib.dot11MaxTransmitMSDULifetime[i] =
+ aCtxImpl.iWlanMib.dot11MaxTransmitMSDULifetimeDefault;
+ aCtxImpl.iWlanMib.iMediumTime[i] = KDot11MediumTimeDefault;
+ }
+
+ // in case WLAN Mgmt Client has given us the permission to use PS mode,
+ // Light PS is the initial desired PS mode configuration
+ aCtxImpl.SetDesiredPsModeConfig(
+ aCtxImpl.ClientLightPsModeConfig() );
+
+ // check do we meet the requirements for the network
+ // and construct necessary objects for doing the connection
+ //
+ return InitNetworkConnect(
+ aCtxImpl,
+ aCtxImpl.ScanResponseFrameBodyLength(),
+ aCtxImpl.ScanResponseFrameBody() );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::SetDot11SlotTime(
+ WlanContextImpl& aCtxImpl )
+ {
+ WHA::Sdot11SlotTime* mib
+ = static_cast<WHA::Sdot11SlotTime*>
+ (os_alloc( sizeof( WHA::Sdot11SlotTime ) ));
+
+ if ( !mib )
+ {
+ // alloc failue just send abort event to fsm
+ // it takes care of the rest
+ Fsm( aCtxImpl, EABORT );
+ return;
+ }
+
+ if ( aCtxImpl.UseShortSlotTime() )
+ {
+ mib->iDot11SlotTime = WHA::KSlotTime9;
+ }
+ else
+ {
+ mib->iDot11SlotTime = WHA::KSlotTime20;
+ }
+
+ OsTracePrint(
+ KUmacDetails,
+ (TUint8*)
+ ("UMAC: WlanDot11Synchronize::SetDot11SlotTime(): set slottime: %d"),
+ mib->iDot11SlotTime );
+
+ WlanWsaWriteMib& wha_cmd = aCtxImpl.WsaWriteMib();
+ wha_cmd.Set(
+ aCtxImpl, WHA::KMibDot11SlotTime, sizeof(*mib), mib );
+
+ // change global state: entry procedure triggers action
+ ChangeState( aCtxImpl,
+ *this, // prev state
+ wha_cmd // next state
+ );
+
+ // as the parameters have been supplied we can now deallocate
+ os_free( mib );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::SetCtsToSelf(
+ WlanContextImpl& aCtxImpl )
+ {
+ WHA::SctsToSelf* mib
+ = static_cast<WHA::SctsToSelf*>
+ (os_alloc( sizeof( WHA::SctsToSelf ) ));
+
+ if ( !mib )
+ {
+ // alloc failue just send abort event to fsm
+ // it takes care of the rest
+ Fsm( aCtxImpl, EABORT );
+ return;
+ }
+
+ if ( aCtxImpl.ProtectionBitSet() )
+ {
+ OsTracePrint(
+ KUmacDetails,
+ (TUint8*)("UMAC: WlanDot11Synchronize::SetCtsToSelf(): enable CTS to self") );
+
+ mib->iCtsToSelf = ETrue;
+ }
+ else
+ {
+ OsTracePrint(
+ KUmacDetails,
+ (TUint8*)("UMAC: WlanDot11Synchronize::SetCtsToSelf(): disable CTS to self") );
+
+ mib->iCtsToSelf = EFalse;
+ }
+
+ WlanWsaWriteMib& wha_cmd = aCtxImpl.WsaWriteMib();
+ wha_cmd.Set(
+ aCtxImpl, WHA::KMibCtsToSelf, sizeof(*mib), mib );
+
+ // change global state: entry procedure triggers action
+ ChangeState( aCtxImpl,
+ *this, // prev state
+ wha_cmd // next state
+ );
+
+ // as the parameters have been supplied we can now deallocate
+ os_free( mib );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::ConfigureQueue(
+ WlanContextImpl& aCtxImpl )
+ {
+ ConfigureTxQueue( aCtxImpl, WHA::ELegacy );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::ConfigureTxQueueParams(
+ WlanContextImpl& aCtxImpl )
+ {
+ WlanConfigureTxQueueParams& complex_wsa_cmd =
+ aCtxImpl.ConfigureTxQueueParams();
+
+ // change global state: entry procedure triggers action
+ ChangeState( aCtxImpl,
+ *this, // prev state
+ complex_wsa_cmd // next state
+ );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::SetTxRatePolicy(
+ WlanContextImpl& aCtxImpl )
+ {
+ OsTracePrint( KUmacDetails, (TUint8*)
+ ("UMAC: WlanDot11Synchronize::SetTxRatePolicy(): rate bitmask: 0x%08x"),
+ aCtxImpl.RateBitMask() );
+
+ if ( !ConfigureTxRatePolicies( aCtxImpl ) )
+ {
+ // alloc failue just send abort event to fsm
+ // it takes care of the rest
+ Fsm( aCtxImpl, EABORT );
+ return;
+ }
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::SetHtCapabilities(
+ WlanContextImpl& aCtxImpl )
+ {
+ OsTracePrint( KUmacDetails, (TUint8*)
+ ("UMAC: WlanDot11Synchronize::SetHtCapabilities") );
+
+ ConfigureHtCapabilities( aCtxImpl );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::SetHtBssOperation(
+ WlanContextImpl& aCtxImpl )
+ {
+ OsTracePrint( KUmacDetails, (TUint8*)
+ ("UMAC: WlanDot11Synchronize::SetHtBssOperation") );
+
+ ConfigureHtBssOperation( aCtxImpl );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::ResetHtCapabilities(
+ WlanContextImpl& aCtxImpl )
+ {
+ OsTracePrint( KUmacDetails, (TUint8*)
+ ("UMAC: WlanDot11Synchronize::ResetHtCapabilities") );
+
+ ResetHtCapabilitiesMib( aCtxImpl );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::ResetHtBlockAckConfiguration(
+ WlanContextImpl& aCtxImpl )
+ {
+ OsTracePrint( KUmacDetails, (TUint8*)
+ ("UMAC: WlanDot11Synchronize::ResetHtBlockAckConfiguration") );
+
+ ResetHtBlockAckConfigureMib( aCtxImpl );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::IssueJoin(
+ WlanContextImpl& aCtxImpl )
+ {
+ OsTracePrint( KUmacDetails, (TUint8*)
+ ("UMAC: WlanDot11Synchronize::IssueJoin"));
+
+ // make WHA types
+ WHA::SSSID ssid;
+ ssid.iSSIDLength = (aCtxImpl.GetSsId()).ssidLength;
+ os_memcpy( ssid.iSSID, (aCtxImpl.GetSsId()).ssid, ssid.iSSIDLength );
+
+ // determine the preamble to be used
+
+ WHA::TPreamble preamble ( WHA::ELongPreamble );
+ if ( aCtxImpl.HtSupportedByNw() )
+ {
+ preamble = (aCtxImpl.GetHtAssociationRequestFrame())
+ .iFixedFields.iCapabilityInfo.IsShortPreambleBitSet() ?
+ WHA::EShortPreamble :
+ WHA::ELongPreamble;
+ }
+ else
+ {
+ preamble = (aCtxImpl.GetAssociationRequestFrame())
+ .iFixedFields.iCapabilityInfo.IsShortPreambleBitSet() ?
+ WHA::EShortPreamble :
+ WHA::ELongPreamble;
+ }
+
+ // set context
+ aCtxImpl.WsaJoin().Set(
+ aCtxImpl,
+ aCtxImpl.NetworkOperationMode(),
+ reinterpret_cast<WHA::TMacAddress&>(aCtxImpl.GetBssId()),
+ WHA::KBand2dot4GHzMask,
+ ssid,
+ aCtxImpl.NetworkChannelNumeber(),
+ aCtxImpl.NetworkBeaconInterval(),
+ aCtxImpl.BasicRateSet(),
+ 0, // ATIM
+ preamble,
+ ( aCtxImpl.WHASettings().iCapability
+ & WHA::SSettings::KProbe4Join ) ? ETrue : EFalse );
+
+ // change global state: entry procedure triggers action
+ ChangeState( aCtxImpl,
+ *this, // prev state
+ aCtxImpl.WsaJoin() // next state
+ );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::SetHtBlockAckConfiguration(
+ WlanContextImpl& aCtxImpl )
+ {
+ OsTracePrint( KUmacDetails, (TUint8*)
+ ("UMAC: WlanDot11Synchronize::SetHtBlockAckConfiguration") );
+
+ // allocate memory for the mib to write
+ WHA::ShtBlockAckConfigure* mib
+ = static_cast<WHA::ShtBlockAckConfigure*>
+ (os_alloc( sizeof( WHA::ShtBlockAckConfigure ) ));
+
+ if ( !mib )
+ {
+ // alloc failue just send abort event to fsm
+ // it takes care of the rest
+ Fsm( aCtxImpl, EABORT );
+ return;
+ }
+
+ // retrieve reference to the stored HT Block Ack configuration
+ const WHA::ShtBlockAckConfigure& blockAckConf (
+ aCtxImpl.GetHtBlockAckConfigure() );
+
+ mib->iTxBlockAckUsage = blockAckConf.iTxBlockAckUsage;
+ mib->iRxBlockAckUsage = blockAckConf.iRxBlockAckUsage;
+ os_memset( mib->iReserved, 0, sizeof( mib->iReserved ) );
+
+ WlanWsaWriteMib& wha_cmd = aCtxImpl.WsaWriteMib();
+
+ wha_cmd.Set(
+ aCtxImpl,
+ WHA::KMibHtBlockAckConfigure,
+ sizeof( *mib ),
+ mib );
+
+ // change global state: entry procedure triggers action
+ ChangeState( aCtxImpl,
+ *this, // prev state
+ wha_cmd ); // next state
+
+ // as the parameters have been supplied we can now deallocate
+ os_free( mib );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11Synchronize::OnWhaCommandResponse(
+ WlanContextImpl& /*aCtxImpl*/,
+ WHA::TCommandId aCommandId,
+ WHA::TStatus aStatus,
+ const WHA::UCommandResponseParams& /*aCommandResponseParams*/,
+ TUint32 aAct )
+ {
+ if ( aAct )
+ {
+ // should not happen as we a runnng in non-pre-emptive mode
+ // regarding oid commands
+ OsTracePrint( KErrorLevel, (TUint8*)("UMAC: aAct: %d"), aAct );
+ OsAssert( (TUint8*)("UMAC: panic"),(TUint8*)(WLAN_FILE), __LINE__ );
+ }
+
+ // this is a response to a command that was generated
+ // by this dot11 state object layer
+
+ // we are only interested of join command response
+ // as it is the oly one we trigger from here that
+ // has a meaningfull return value
+ if ( aCommandId == WHA::EJoinResponse )
+ {
+ if ( aStatus == WHA::KFailed )
+ {
+ OsTracePrint( KWarningLevel, (TUint8*)
+ ("UMAC: WlanDot11Synchronize::OnWhaCommandResponse(): join failed"));
+ // make a note of the failure and act
+ // accordingly when we
+ // soon again enter this state
+ iJoinFailed = ETrue;
+ }
+ else
+ {
+ OsTracePrint( KInfoLevel,
+ (TUint8*)("UMAC: WlanDot11Synchronize::OnWhaCommandResponse(): join success"));
+ }
+ }
+ else // --- aCommandId == WHA::EJoinResponse ---
+ {
+ // no action here
+ }
+ }