diff -r 000000000000 -r c40eb8fe8501 wlan_bearer/wlanldd/wlan_common/umac_common/src/UmacDot11Synchronize.cpp --- /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(&(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 + (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 + (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(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 + (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 + } + }