--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/wlan_bearer/wlanldd/wlan_common/umac_common/src/UmacDot11InitPhase1.cpp Tue Feb 02 02:03:13 2010 +0200
@@ -0,0 +1,672 @@
+/*
+* Copyright (c) 2002-2008 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 WlanDot11InitPhase1 class
+*
+*/
+
+/*
+* %version: 34 %
+*/
+
+#include "config.h"
+#include "UmacDot11InitPhase1.h"
+#include "UmacContextImpl.h"
+#include "UmacWsaInitiliaze.h"
+#include "UmacWsaConfigure.h"
+#include "UmacWsaReadMib.h"
+#include "umacconfiguretxqueueparams.h"
+
+#ifndef NDEBUG
+const TInt8 WlanDot11InitPhase1::iName[] = "dot11-initphase";
+
+const TUint8 WlanDot11InitPhase1::iStateName
+ [ESTATEMAX][KMaxStateStringLength] =
+ {
+ {"EINIT"},
+ {"EINITILIAZE"},
+ {"ECOMPLETEBOOTUP"},
+ {"EWAIT4OIDCONFIGURE"},
+ {"EHANDLEOIDCONFIGURE"},
+ {"ECONFIGURE"},
+ {"EREADSTATIONID"},
+ {"ECONFTXQUEUE"},
+ {"ECONTINUEDOT11TRAVERSE"}
+ };
+
+const TUint8 WlanDot11InitPhase1::iEventName
+ [EEVENTMAX][KMaxEventStringLength] =
+ {
+ {"ESTATEENTRY"}, {"ETXCOMPLETE"}, {"EOIDCONFIGURE"}, {"EABORT"}
+ };
+#endif
+
+// ================= MEMBER FUNCTIONS =======================
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+WlanDot11InitPhase1::~WlanDot11InitPhase1()
+ {
+ iPda = NULL;
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+#ifndef NDEBUG
+const TInt8* WlanDot11InitPhase1::GetStateName(
+ TUint8& aLength ) const
+ {
+ aLength = sizeof( iName );
+ return iName;
+ }
+#endif
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11InitPhase1::Entry( WlanContextImpl& aCtxImpl)
+ {
+ if ( aCtxImpl.WsaCmdActive() )
+ {
+ // sanity checking code
+ OsAssert( (TUint8*)("UMAC * panic"),
+ (TUint8*)(WLAN_FILE), __LINE__ );
+ }
+
+ // no need to do event dispatching in here
+
+ 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 WlanDot11InitPhase1::Exit( WlanContextImpl& aCtxImpl)
+ {
+ // executed upon dot11 state traversal to another dot11 state
+ // reset local statemachine
+ // and set user completion code
+ aCtxImpl.iStates.iIdleState.Set( KErrNone );
+ iState = EINIT;
+
+ // always deallocate
+ OsTracePrint( KInitLevel,
+ (TUint8*)("UMAC * dot11-initphase * free pda memory") );
+ os_free( iPda );
+ iPda = NULL;
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+inline void WlanDot11InitPhase1::ChangeInternalState(
+ WlanContextImpl& aCtxImpl,
+ TState aNewState )
+ {
+ iState = aNewState;
+ Fsm( aCtxImpl, ESTATEENTRY );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11InitPhase1::Fsm(
+ WlanContextImpl& aCtxImpl,
+ TEvent aEvent )
+ {
+ OsTracePrint( KUmacDetails,
+ (TUint8*)("UMAC * dot11-initphase * FSM EVENT") );
+#ifndef NDEBUG
+ OsTracePrint( KUmacDetails, (TUint8*)("event:"));
+ OsTracePrint( KUmacDetails, iEventName[aEvent] );
+ OsTracePrint( KUmacDetails, (TUint8*)("state:"));
+ OsTracePrint( KUmacDetails, iStateName[iState] );
+#endif
+
+ switch ( aEvent )
+ {
+ case ESTATEENTRY:
+ OnStateEntryEvent( aCtxImpl );
+ break;
+ case ETXCOMPLETE:
+ OnTxCompleteEvent( aCtxImpl );
+ break;
+ case EOIDCONFIGURE:
+ OnOIDConfigureEvent( aCtxImpl );
+ break;
+ case EABORT:
+ OnAbortEvent( aCtxImpl );
+ break;
+ default:
+ // catch internal FSM programming error
+ OsAssert( (TUint8*)("* UMAC * panic"),
+ (TUint8*)(WLAN_FILE), __LINE__ );
+ break;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// WlanDot11InitPhase1::OnStateEntryEvent
+// Handler for state entry event.
+// It is guaranteed by the FSM framework that no WHA command is pending
+// when this method is entered
+// -----------------------------------------------------------------------------
+//
+void WlanDot11InitPhase1::OnStateEntryEvent(
+ WlanContextImpl& aCtxImpl )
+ {
+ switch ( iState )
+ {
+ case EINIT:
+ // start the FSM traversal
+ ChangeInternalState( aCtxImpl, EINITILIAZE );
+ break;
+ case EINITILIAZE:
+ Initialize( aCtxImpl );
+ break;
+ case ECOMPLETEBOOTUP:
+ CompleteOid( aCtxImpl );
+ ChangeInternalState( aCtxImpl, EWAIT4OIDCONFIGURE );
+ break;
+ case EWAIT4OIDCONFIGURE:
+ // nothing
+ break;
+ case EHANDLEOIDCONFIGURE:
+ HandleOIDConfigure( aCtxImpl );
+ ChangeInternalState( aCtxImpl, ECONFIGURE );
+ break;
+ case ECONFIGURE:
+ Configure( aCtxImpl );
+ break;
+ case EREADSTATIONID:
+ ReadStationID( aCtxImpl );
+ break;
+ case ECONFTXQUEUE:
+ // configure just the legacy Tx queue
+ ConfigureQueue( aCtxImpl );
+ break;
+ case ECONTINUEDOT11TRAVERSE:
+ // our dot11 transition is fixed and we shall take it
+ // change global dot11 state: entry procedure triggers action
+ // but first we shall construct a rate lookup table
+ aCtxImpl.MakeLookUpTable();
+
+ if ( aCtxImpl.WHASettings().iCapability &
+ WHA::SSettings::KHtOperation )
+ {
+ // HT supported by lower layer. As our HT capabilities can't
+ // change dynamically, we'll configure our HT capabilities
+ // element only once; and we do it here
+ ConfigureOurHtCapabilitiesElement( aCtxImpl );
+ }
+
+ ChangeState( aCtxImpl,
+ *this, // prev state
+ aCtxImpl.iStates.iMibDefaultConfigure // next state
+ );
+ break;
+ default:
+ // catch internal FSM programming error
+ OsTracePrint( KErrorLevel, (TUint8*)("UMAC: state: %d"), iState);
+ OsAssert( (TUint8*)("UMAC: panic"), (TUint8*)(WLAN_FILE), __LINE__ );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// WlanDot11MibDefaultConfigure::OnTxCompleteEvent
+// Handler for tx complete event.
+// It is guaranteed by the FSM framework that no WHA command is pending
+// when this method is entered
+// -----------------------------------------------------------------------------
+//
+void WlanDot11InitPhase1::OnTxCompleteEvent(
+ WlanContextImpl& aCtxImpl )
+ {
+ switch ( iState )
+ {
+ case EINITILIAZE:
+ ChangeInternalState( aCtxImpl, ECOMPLETEBOOTUP );
+ break;
+ case ECONFIGURE:
+ ChangeInternalState( aCtxImpl, EREADSTATIONID );
+ break;
+ case EREADSTATIONID:
+ ChangeInternalState( aCtxImpl, ECONFTXQUEUE );
+ break;
+ case ECONFTXQUEUE:
+ ChangeInternalState( aCtxImpl, ECONTINUEDOT11TRAVERSE );
+ break;
+ default:
+ // catch internal FSM programming error
+ OsTracePrint( KErrorLevel, (TUint8*)("UMAC: state: %d"), iState);
+ OsAssert( (TUint8*)("UMAC: panic"), (TUint8*)(WLAN_FILE), __LINE__ );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// simulate macnotresponding error
+// -----------------------------------------------------------------------------
+//
+void WlanDot11InitPhase1::OnAbortEvent( WlanContextImpl& aCtxImpl )
+ {
+ OsTracePrint( KWarningLevel, (TUint8*)("UMAC * dot11-initphase * abort") );
+
+ DoErrorIndication( aCtxImpl, WHA::KErrorMacNotResponding );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11InitPhase1::OnOIDConfigureEvent(
+ WlanContextImpl& aCtxImpl )
+ {
+ switch ( iState )
+ {
+ case EWAIT4OIDCONFIGURE:
+ ChangeInternalState( aCtxImpl, EHANDLEOIDCONFIGURE );
+ break;
+ default:
+ // catch internal FSM programming error
+ OsTracePrint( KErrorLevel, (TUint8*)("UMAC * state: %d"), iState);
+ OsAssert(
+ (TUint8*)("UMAC * panic"), (TUint8*)(WLAN_FILE), __LINE__ );
+ break;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11InitPhase1::Initialize(
+ WlanContextImpl& aCtxImpl )
+ {
+ ChangeState( aCtxImpl,
+ *this, // previous state
+ aCtxImpl.WsaInitiliaze() // next state
+ );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11InitPhase1::Configure( WlanContextImpl& aCtxImpl )
+ {
+ // set dot11maxtransmitmsdulifetime
+ WHA::SConfigureDataBase* ptr
+ = reinterpret_cast<WHA::SConfigureDataBase*>(iPda);
+ ptr->iDot11MaxTransmitMsduLifeTime
+ = aCtxImpl.iWlanMib.dot11MaxTransmitMSDULifetimeDefault;
+
+ // set context for configure
+ aCtxImpl.WsaConfigure().Set( aCtxImpl, iPda, iPdaLen );
+ ChangeState( aCtxImpl,
+ *this, // previous state
+ aCtxImpl.WsaConfigure() // next state
+ );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11InitPhase1::ReadStationID( WlanContextImpl& aCtxImpl )
+ {
+ aCtxImpl.WsaReadMib().Set( aCtxImpl, WHA::KMibDot11StationId );
+ // change global state: entry procedure triggers action
+ ChangeState( aCtxImpl,
+ *this, // previous state
+ aCtxImpl.WsaReadMib() // next state
+ );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11InitPhase1::CompleteOid( WlanContextImpl& aCtxImpl ) const
+ {
+ // this is just an oid for us to complete...
+ OnOidComplete( aCtxImpl );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11InitPhase1::HandleOIDConfigure( WlanContextImpl& aCtxImpl )
+ {
+ OnConfigureUmacMib( aCtxImpl, iRTSThreshold, iMaxTxMSDULifetime );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void WlanDot11InitPhase1::ConfigureQueue(
+ WlanContextImpl& aCtxImpl )
+ {
+ ConfigureTxQueue( aCtxImpl, WHA::ELegacy );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11InitPhase1::OnWhaCommandResponse(
+ WlanContextImpl& aCtxImpl,
+ WHA::TCommandId aCommandId,
+ WHA::TStatus aStatus,
+ const WHA::UCommandResponseParams& aCommandResponseParams,
+ TUint32 aAct )
+ {
+ if ( !aAct )
+ {
+ // this is a response to a command that was generated
+ // by this dot11 state object layer
+ if ( aCommandId == WHA::EReadMIBResponse )
+ {
+ // store station ID to UMAC MIB
+ os_memcpy(
+ &(aCtxImpl.iWlanMib.dot11StationId),
+ aCommandResponseParams.iReadMibResponse.iData,
+ sizeof(aCtxImpl.iWlanMib.dot11StationId) );
+
+ // trace the critter
+ OsTracePrint( KUmacDetails,
+ (TUint8*)("UMAC * MAC address of the interface: "),
+ aCtxImpl.iWlanMib.dot11StationId );
+
+ // as station id has been received
+ // we shall configure the frame templates
+ ConfigureUmacFrameTemplates( aCtxImpl );
+ }
+ else // -- aCommandId == WHA::EReadMIBResponse
+ {
+ // nothing else is no interest to us
+ }
+ }
+ else // -- aAct != WlanDot11State::KCompleteManagementRequest
+ {
+ // this is a response to a command that was not generated
+ // by this dot11 state object layer
+ // so lets forward it to the default handler
+ WlanDot11State::OnWhaCommandResponse(
+ aCtxImpl,
+ aCommandId,
+ aStatus,
+ aCommandResponseParams,
+ aAct );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11InitPhase1::FinitSystem( WlanContextImpl& aCtxImpl )
+ {
+ OsTracePrint( KUmacDetails, (TUint8*)
+ ("UMAC: WlanDot11InitPhase1::FinitSystem") );
+
+ // if the control comes here it means that we have not been able to
+ // initialize the system, which also means that WHA::Initialize() has not
+ // been called yet, but we are nevertheless instructed to stop using the
+ // system. As WHA::Initialize() hasn't been called, there's no need to ask
+ // WHA layer to release its resources (call WHA::Release()) in this
+ // situation. So the only thing we need to do is to complete the WLAN Mgmt
+ // Client request (with ok status)
+ OnOidComplete( aCtxImpl );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11InitPhase1::ConfigureUmacFrameTemplates(
+ WlanContextImpl& aCtxImpl ) const
+ {
+ OsTracePrint( KUmacDetails,
+ (TUint8*)("UMAC: WlanDot11InitPhase1::ConfigureUmacFrameTemplates") );
+
+ // set our station id to association request,
+ // deauthentication, disassociation and reassociation
+ // frame header templates
+ aCtxImpl.GetAssociationRequestFrame().iHeader.iSA
+ = aCtxImpl.iWlanMib.dot11StationId;
+ aCtxImpl.GetHtAssociationRequestFrame().iHeader.iSA
+ = aCtxImpl.iWlanMib.dot11StationId;
+ aCtxImpl.GetDeauthenticateFrame().iHeader.iSA
+ = aCtxImpl.iWlanMib.dot11StationId;
+ aCtxImpl.GetHtDeauthenticateFrame().iHeader.iSA
+ = aCtxImpl.iWlanMib.dot11StationId;
+ aCtxImpl.GetDisassociationFrame().iHeader.iSA
+ = aCtxImpl.iWlanMib.dot11StationId;
+ aCtxImpl.GetHtDisassociationFrame().iHeader.iSA
+ = aCtxImpl.iWlanMib.dot11StationId;
+ aCtxImpl.GetReassociationRequestFrame().iHeader.iSA
+ = aCtxImpl.iWlanMib.dot11StationId;
+ aCtxImpl.GetHtReassociationRequestFrame().iHeader.iSA
+ = aCtxImpl.iWlanMib.dot11StationId;
+
+ // set up NULL data frame
+ SNullDataFrame& null_data = aCtxImpl.NullDataFrame();
+ null_data.iFrameControl.iType
+ = E802Dot11FrameTypeDataNull;
+ null_data.iAddress2 = aCtxImpl.iWlanMib.dot11StationId;
+
+ // set up QoS NULL data frame
+ SHtQosNullDataFrame& qosNullData = aCtxImpl.QosNullDataFrame();
+ qosNullData.iQosDataFrameHdr.iHdr.iFrameControl.iType
+ = E802Dot11FrameTypeQosDataNull;
+ qosNullData.iQosDataFrameHdr.iHdr.iAddress2 =
+ aCtxImpl.iWlanMib.dot11StationId;
+ // reset the QoS control field => normal ack requested
+ qosNullData.iQosDataFrameHdr.ResetQosControl();
+ // clear the HT control field. Lower layer(s) will set it when applicable
+ qosNullData.ResetHtControl();
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11InitPhase1::ConfigureOurHtCapabilitiesElement(
+ WlanContextImpl& aCtxImpl ) const
+ {
+ OsTracePrint( KUmacDetails, (TUint8*)
+ ("UMAC: WlanDot11InitPhase1::ConfigureOurHtCapabilitiesElement") );
+
+ // configure HT capabilities info field
+ //
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetLdpcRx(
+ aCtxImpl.WHASettings().iHtCapabilities.iHTCapabilitiesBitMask &
+ WHA::KLdpcRx );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetFortyMhzOperation(
+ aCtxImpl.WHASettings().iHtCapabilities.iHTCapabilitiesBitMask &
+ WHA::K40MhzChannel );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetSmPowerSave(
+ SHtCapabilitiesIeData::ESmPowerSaveDisabled );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetGreenfieldFormat(
+ aCtxImpl.WHASettings().iHtCapabilities.iHTCapabilitiesBitMask &
+ WHA::KGreenfieldFormat );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetShortGiFor20Mhz(
+ aCtxImpl.WHASettings().iHtCapabilities.iHTCapabilitiesBitMask &
+ WHA::KShortGiFor20Mhz );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetShortGiFor40Mhz(
+ aCtxImpl.WHASettings().iHtCapabilities.iHTCapabilitiesBitMask &
+ WHA::KShortGiFor40Mhz );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetStbcTx(
+ aCtxImpl.WHASettings().iHtCapabilities.iHTCapabilitiesBitMask &
+ WHA::KStbcTx );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetStbcRx(
+ aCtxImpl.WHASettings().iHtCapabilities.iRxStbc );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetDelayedBlockAck(
+ aCtxImpl.WHASettings().iHtCapabilities.iHTCapabilitiesBitMask &
+ WHA::KDelayedBlockAck );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetMaxAmsduLength(
+ aCtxImpl.WHASettings().iHtCapabilities.iMaxAmsdu );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetDsssCckIn40Mhz(
+ aCtxImpl.WHASettings().iHtCapabilities.iHTCapabilitiesBitMask &
+ WHA::KDsssCckIn40Mhz );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetPsmp(
+ aCtxImpl.WHASettings().iHtCapabilities.iHTCapabilitiesBitMask &
+ WHA::KPsmp );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetLsigTxopProtection(
+ aCtxImpl.WHASettings().iHtCapabilities.iHTCapabilitiesBitMask &
+ WHA::KLsigTxopProtection );
+
+ // configure A-MPDU parameters field
+ //
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetMaxAmpduLenExponent(
+ aCtxImpl.WHASettings().iHtCapabilities.iMaxAmpdu );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetMinMpduStartSpacing(
+ aCtxImpl.WHASettings().iHtCapabilities.iAmpduSpacing );
+
+ // configure supported MCS set field
+ //
+ os_memcpy(
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.iRxMcsBitmask,
+ aCtxImpl.WHASettings().iHtCapabilities.iRxMcs,
+ sizeof( aCtxImpl.GetOurHtCapabilitiesIe().iData.iRxMcsBitmask ) );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetMaxRxDataRate(
+ aCtxImpl.WHASettings().iHtCapabilities.iRxMaxDataRate );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetTxMcsSetDefined( ETrue );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetTxRxMcsSetNotEqual(
+ os_memcmp(
+ aCtxImpl.WHASettings().iHtCapabilities.iRxMcs,
+ aCtxImpl.WHASettings().iHtCapabilities.iTxMcs,
+ sizeof( WHA::THtMcsSet ) ) );
+
+ // configure HT extended capabilities field
+ //
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetPco(
+ aCtxImpl.WHASettings().iHtCapabilities.iHTCapabilitiesBitMask &
+ WHA::KPco );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetPcoTransitionTime(
+ aCtxImpl.WHASettings().iHtCapabilities.iPcoTransTime );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetMcsFeedback(
+ aCtxImpl.WHASettings().iHtCapabilities.iMcsFeedback );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetHtc(
+ aCtxImpl.WHASettings().iHtCapabilities.iHTCapabilitiesBitMask &
+ WHA::KHtcField );
+ aCtxImpl.GetOurHtCapabilitiesIe().iData.SetRdResponder(
+ aCtxImpl.WHASettings().iHtCapabilities.iHTCapabilitiesBitMask &
+ WHA::KReverseDirectionResp );
+
+ // transmit beamforming capabilities; remains all zero
+
+ // antenna selection capability; remains all zero
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void WlanDot11InitPhase1::BootUp(
+ WlanContextImpl& aCtxImpl,
+ const TUint8* aPda,
+ TUint32 aPdaLength,
+ const TUint8* aFw,
+ TUint32 aFwLength )
+ {
+ // allocate storage for pda
+ // pda must remain valid longer as we get dot11maxtransmitmsdulifetime
+ // from oid-configure
+ OsTracePrint( KInitLevel,
+ (TUint8*)("UMAC * dot11-initphase * FSM EVENT") );
+
+ iPda = static_cast<TUint8*>(os_alloc( aPdaLength ));
+ if ( iPda )
+ {
+ OsTracePrint( KInitLevel,
+ (TUint8*)("UMAC * dot11-initphase * allocate pda memory") );
+ OsTracePrint( KInitLevel, (TUint8*)("length: %d"), aPdaLength );
+
+ iPdaLen = aPdaLength;
+ os_memcpy( iPda, aPda, iPdaLen );
+ // set ctx for fw upload
+ aCtxImpl.WsaInitiliaze().Set( aCtxImpl, aFw, aFwLength );
+ }
+ else
+ {
+ // allocation failure -> abort
+ OsTracePrint( KWarningLevel, (TUint8*)
+ ("UMAC * dot11-initphase * pda memory allocation failure") );
+ Fsm( aCtxImpl, EABORT );
+ }
+
+ // manually start the fsm
+ Entry( aCtxImpl );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+TBool WlanDot11InitPhase1::Configure(
+ WlanContextImpl& aCtxImpl,
+ TUint32 aRTSThreshold,
+ TUint32 aMaxTxMSDULifetime,
+ TUint32 aVoiceCallEntryTimeout,
+ TUint32 aVoiceCallEntryTxThreshold,
+ TUint32 aVoiceNullTimeout,
+ TUint32 aNoVoiceTimeout,
+ TUint32 aKeepAliveTimeout,
+ TUint32 aSpRcpiIndicationLevel,
+ TUint32 aSpTimeToCountPrediction,
+ TUint32 aSpMinIndicationInterval )
+ {
+ // store parameters and feed an event to the fsm
+ iRTSThreshold = aRTSThreshold;
+ iMaxTxMSDULifetime = aMaxTxMSDULifetime;
+ aCtxImpl.SetNullSendControllerParameters(
+ aVoiceCallEntryTimeout,
+ aVoiceCallEntryTxThreshold,
+ aVoiceNullTimeout,
+ aNoVoiceTimeout,
+ aKeepAliveTimeout );
+
+ aCtxImpl.ConfigureWlanSignalPredictor(
+ aSpTimeToCountPrediction,
+ aSpMinIndicationInterval,
+ static_cast<WHA::TRcpi>(aSpRcpiIndicationLevel) );
+
+ Fsm( aCtxImpl, EOIDCONFIGURE );
+
+ // state transition will occur upon this
+ return ETrue;
+ }