/*

* 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