/*

* Copyright (c) 2005-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 WlanDot11InfrastructureModeInit class

*

*/

/*

* %version: 40 %

*/

#include "config.h"

#include "UmacDot11InfrastructureModeInit.h"

#include "UmacContextImpl.h"

#include "UmacWsaWriteMib.h"

#include "UmacWsaSetBssParameters.h"

#include "umacelementlocator.h"

// amount of memory allocated in the mib write buffer

const TUint KMibBufferAllocLen( 100 );

#ifndef NDEBUG

const TInt8 WlanDot11InfrastructureModeInit::iName[] 

    = "dot11-infrastructuremodeinit";

const TUint8 WlanDot11InfrastructureModeInit::iStateName

    [ESTATEMAX][KMaxStateStringLength] = 

    {

        {"EINIT"}, 

        {"EENABLEBEACONRX"}, 

        {"ESETNULLDATAFRAMETEMPLATE"},

        {"ESETQOSNULLDATAFRAMETEMPLATE"},

        {"ESETPSPOLLTEMPLATE"},

        {"EWAIT4BEACON"}, 

        {"EDISABLEBEACONRX"},                         

        {"ESETBSSPARAMS"}, 

        {"ECONFBEACONFILTERIETABLE"}, 

        {"EWAIT4USERDATAENABLE"}, 

        {"ECONTINUEDOT11TRAVERSE"}

    };

const TUint8 WlanDot11InfrastructureModeInit::iEventName

    [EEVENTMAX][KMaxEventStringLength] = 

    {

        {"ESTATEENTRY"}, 

        {"ETXCOMPLETE"}, 

        {"EBEACONPROCESSED"},

        {"EUSERDATAENABLE"}, 

        {"EABORT"} 

    };

#endif

// beacon has been processed

const TUint32 KBeaconHandled        = (1 << 0);

// scan OID has been issued

const TUint32 KScanning             = (1 << 1);

// BSS Parameters have been set

const TUint32 KBssParamsSet       	= (1 << 2);

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

WlanDot11InfrastructureModeInit::~WlanDot11InfrastructureModeInit()

    {

    iMibMemoryBuffer = NULL;

    }

#ifndef NDEBUG 

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

const TInt8* WlanDot11InfrastructureModeInit::GetStateName( 

    TUint8& aLength ) const

    {

    aLength = sizeof( iName );

    return iName;

    }

#endif

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

void WlanDot11InfrastructureModeInit::Entry( 

    WlanContextImpl& aCtxImpl)

    {

    if ( aCtxImpl.WsaCmdActive() )

        {

        // sanity checking code

        OsAssert( (TUint8*)("UMAC* panic"), (TUint8*)(WLAN_FILE), __LINE__ );

        }

    if ( !(aCtxImpl.DispatchEvent()) )

        {

        // no state transition occurred

        // dispatcher might or might not have had an event to be dispatched

        // in any case we are still in the current state and can continue...

        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 );

            }

        }

    else    // --- !(aCtxImpl.DispatchEvent())

        {

        // state transition occurred

        // we are no longer in the current state,

        // so we won't do anything as we might mess things up

        }   

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

void WlanDot11InfrastructureModeInit::Exit( 

    WlanContextImpl& /*aCtxImpl*/ )

    {

    if ( !(iFlags & KScanning) )

        {

        // we are about to make a transition to another dot11 state

        // and that state is not the scanning state

        // from scanning state we shall come back to this dot11 state

        // so basically this means that

        // only thing we shall do is to reset our FSM for the next round...

        iState = EINIT; 

        os_free( iMibMemoryBuffer );

        iMibMemoryBuffer = NULL;

        }

    else

        {

        iFlags &= ~KScanning;

        OsTracePrint( KScan, (TUint8*)

            ("UMAC * dot11-infrastructuremodeinit * switch to scan mode") );

        }

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

inline void WlanDot11InfrastructureModeInit::ChangeInternalState( 

    WlanContextImpl& aCtxImpl, 

    TState aNewState )

    {

    iState = aNewState;

    Fsm( aCtxImpl, ESTATEENTRY );

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

void WlanDot11InfrastructureModeInit::Fsm( 

    WlanContextImpl& aCtxImpl, 

    TEvent aEvent )

    {

    OsTracePrint( KUmacDetails, 

        (TUint8*)("UMAC * dot11-infrastructuremodeinit * 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 EBEACONPROCESSED:

            OnBeaconProcessedEvent( aCtxImpl );

            break;

        case EUSERDATAENABLE:

            OnUserDataEnableEvent( aCtxImpl );

            break;

        case EABORT:

            OnAbortEvent( aCtxImpl );            

            break;

        default:

            // catch internal FSM programming error

#ifndef NDEBUG

            OsTracePrint( KErrorLevel, (TUint8*)("event:"));

            OsTracePrint( KErrorLevel, iEventName[aEvent] );                

#endif

            OsAssert( (TUint8*)("* UMAC * panic"), 

                (TUint8*)(WLAN_FILE), __LINE__ );

            break;

        }

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

void WlanDot11InfrastructureModeInit::OnStateEntryEvent( 

    WlanContextImpl& aCtxImpl )

    {

    switch ( iState )

        {

        case EINIT:                

            iMibMemoryBuffer = os_alloc( KMibBufferAllocLen );

            if ( iMibMemoryBuffer )

                {

                // reset event flag and continue with the state traversal

                iFlags = 0;

                ChangeInternalState( aCtxImpl, EENABLEBEACONRX );

                }

            else

                {

                // allocation failure

                Fsm( aCtxImpl, EABORT );

                }

            break;

        case EENABLEBEACONRX:

            // enable beacon frame reception

            EnableBeaconRx( aCtxImpl );

            break;

        case ESETNULLDATAFRAMETEMPLATE:

            // configure NULL data frame template

            SetNullDataFrameTemplate( aCtxImpl );

            break;

        case ESETQOSNULLDATAFRAMETEMPLATE:

            // configure NULL data frame template

            SetQosNullDataFrameTemplate( aCtxImpl );

            break;

        case ESETPSPOLLTEMPLATE:

            // configure ps poll frame template

            SetPsPollFrameTemplate( aCtxImpl );

            break;

        case ESETBSSPARAMS:

            // set the BSS parameters

            SetBssParams( aCtxImpl );

            break;

        case EDISABLEBEACONRX:

            // disable beacon frame reception

            DisableBeaconRx( aCtxImpl );

            break;

        case ECONFBEACONFILTERIETABLE:

            // configure beaconfiltertable MIB

            ConfigureBeaconFilterIeTable( aCtxImpl );

            break;

        case ECONTINUEDOT11TRAVERSE:

            // continue dot11 state traversal to dot11awake mode

            // or to dot11eneterdoze state

            ContinueDot11StateTraversal( aCtxImpl );

            break;        

        // these critters don't have an entry action

        // but the entry event gets sent automatically by the framework 

        // from state traversal method so they have to be defined here

        case EWAIT4BEACON:

        case EWAIT4USERDATAENABLE:

            break;

        default:

            // catch internal FSM programming error

            OsTracePrint( 

                KErrorLevel, 

                (TUint8*)

                ("UMAC: WlanDot11InfrastructureModeInit::OnStateEntryEvent(): state: %d"), 

                iState);        

            OsAssert( 

                (TUint8*)

                ("UMAC: WlanDot11InfrastructureModeInit::OnStateEntryEvent(): panic"), 

                (TUint8*)(WLAN_FILE), __LINE__ );

            break;

        }

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

void WlanDot11InfrastructureModeInit::OnTxCompleteEvent( 

    WlanContextImpl& aCtxImpl )

    {

    switch ( iState )

        {

        case EWAIT4BEACON:

            // event handler for this state is needed

            // as we may re-enter this dot11 state (e.g. from scanning state 

            // or because we autonomously requested a WHA cmd to be executed)

            // while waiting for this event to occur

            if ( iFlags & KBeaconHandled )

                {

                // give a correct event for the FSM critter

                Fsm( aCtxImpl, EBEACONPROCESSED );

                }

            break;

        case EWAIT4USERDATAENABLE:

            // event handler for this state is needed

            // as we may re-enter this dot11 state (e.g. from scanning state 

            // or because we autonomously requested a WHA cmd to be executed)

            // while waiting for this event to occur

            if ( aCtxImpl.ProtocolStackTxDataAllowed() )

                {

                // give a correct event for the FSM critter

                Fsm( aCtxImpl, EUSERDATAENABLE );

                }

            break;

        case EENABLEBEACONRX:

            ChangeInternalState( aCtxImpl, 

                ESETNULLDATAFRAMETEMPLATE );

            break;

        case ESETNULLDATAFRAMETEMPLATE:

            ChangeInternalState( aCtxImpl, 

                ESETQOSNULLDATAFRAMETEMPLATE );

            break;

        case ESETQOSNULLDATAFRAMETEMPLATE:

            ChangeInternalState( aCtxImpl, 

                ESETPSPOLLTEMPLATE );

            break;

        case ESETPSPOLLTEMPLATE:

            // as we have configured the ps poll frame we shall now

            // complete the request

            CompleteConnectRequest( aCtxImpl, KErrNone );

            ChangeInternalState( aCtxImpl, 

                EWAIT4BEACON );

            break;

        case EDISABLEBEACONRX:

            ChangeInternalState( aCtxImpl, 

                ESETBSSPARAMS );

            break;

        case ESETBSSPARAMS:

            ChangeInternalState( aCtxImpl, 

                ECONFBEACONFILTERIETABLE );

            break;

        case ECONFBEACONFILTERIETABLE:

            if ( aCtxImpl.ProtocolStackTxDataAllowed() )

                {

                // user data enabled continue

                // state traversal

                ChangeInternalState( aCtxImpl, 

                    ECONTINUEDOT11TRAVERSE );

                }

            else

                {

                // user data is not enabled wait 4 it

                ChangeInternalState( aCtxImpl, 

                    EWAIT4USERDATAENABLE );

                }

            break;

        default:

            // catch internal FSM programming error

            OsTracePrint( KErrorLevel, (TUint8*)("state: %d"), iState);        

            OsAssert( (TUint8*)("UMAC * panic"), 

                (TUint8*)(WLAN_FILE), __LINE__ );

            break;

        }

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

void WlanDot11InfrastructureModeInit::OnBeaconProcessedEvent( 

    WlanContextImpl& aCtxImpl )

    {

    switch ( iState )

        {

        case EWAIT4BEACON:

            // continue state traversal

            ChangeInternalState( aCtxImpl, EDISABLEBEACONRX );

            break;        

        default:

            // if the beacon gets processed in an earlier internal

            // state than EWAIT4BEACON, we won't change to 

            // EDISABLEBEACONRX as it would disrupt the sequence 

            // of actions. So we will do this internal state change

            // later in its due time            

            break;

        }

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

void WlanDot11InfrastructureModeInit::OnUserDataEnableEvent( 

    WlanContextImpl& aCtxImpl )

    {

    // continue state traversal

    ChangeInternalState( aCtxImpl, ECONTINUEDOT11TRAVERSE );

    }

// ---------------------------------------------------------

// simulate macnotresponding error

// ---------------------------------------------------------

//

void WlanDot11InfrastructureModeInit::OnAbortEvent( 

    WlanContextImpl& aCtxImpl )

    {

    OsTracePrint( KWarningLevel, 

        (TUint8*)("UMAC * dot11-infrastructuremodeinit * abort") );

    DoErrorIndication( aCtxImpl, WHA::KErrorMacNotResponding );

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

void WlanDot11InfrastructureModeInit::EnableBeaconRx( 

    WlanContextImpl& aCtxImpl )

    {    

    const TUint32 KBeaconRxEnableValue( 1 );

    WHA::SbeaconFilterEnable* mib 

        = static_cast<WHA::SbeaconFilterEnable*>(iMibMemoryBuffer);

    // enable reception of every beacon from the BSS 

    mib->iEnable = EFalse;

    // even though this attribute is nowadays deprecated, we still continue to

    // set it in this case; to be on the safe side

    mib->iCount = KBeaconRxEnableValue;

    WlanWsaWriteMib& wsa_cmd = aCtxImpl.WsaWriteMib();

    wsa_cmd.Set( 

        aCtxImpl, WHA::KMibBeaconFilterEnable, sizeof(*mib), mib );

    // change global state: entry procedure triggers action

    ChangeState( aCtxImpl, 

        *this,              // prev state

        wsa_cmd             // next state

        );   

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

void WlanDot11InfrastructureModeInit::DisableBeaconRx( 

    WlanContextImpl& aCtxImpl )

    {    

    const TUint32 KBeaconRxDisableValue( 0 );

    WHA::SbeaconFilterEnable* mib 

        = static_cast<WHA::SbeaconFilterEnable*>(iMibMemoryBuffer);

    // disable reception of beacons except those specified 

    // by beaconFilterIeTable

    mib->iEnable = ETrue;

    mib->iCount = KBeaconRxDisableValue;

    WlanWsaWriteMib& wsa_cmd = aCtxImpl.WsaWriteMib();

    wsa_cmd.Set( 

        aCtxImpl, WHA::KMibBeaconFilterEnable, sizeof(*mib), mib );

    // change global state: entry procedure triggers action

    ChangeState( aCtxImpl, 

        *this,              // prev state

        wsa_cmd             // next state

        );           

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

void WlanDot11InfrastructureModeInit::SetNullDataFrameTemplate( 

    WlanContextImpl& aCtxImpl )

    {

    TUint32 mibLength( 

        WHA::StemplateFrame::KHeaderSize

        + sizeof( SNullDataFrame ) ); 

    // align length of MIB to 4-byte boundary

    mibLength = Align4( mibLength );

    if ( mibLength > KMibBufferAllocLen )

        {

        // programming error

        OsTracePrint( KErrorLevel, (TUint8*)("UMAC: mib length: %d"), mibLength);

        OsAssert( (TUint8*)("UMAC: panic"), (TUint8*)(WLAN_FILE), __LINE__ );

        }

    WHA::StemplateFrame* mib 

        = static_cast<WHA::StemplateFrame*>(iMibMemoryBuffer);

    mib->iFrameType = WHA::KNullDataTemplate;

    mib->iInitialTransmitRate = InitialSpecialFrameTxRate( aCtxImpl );

    mib->iLength = sizeof( SNullDataFrame );

    // copy the null data frame after the mib header

    os_memcpy( mib->iTemplateData,

               reinterpret_cast<TUint8*>(&(aCtxImpl.NullDataFrame())),

               sizeof( SNullDataFrame ) );

    WlanWsaWriteMib& wsa_cmd = aCtxImpl.WsaWriteMib();

    wsa_cmd.Set( 

        aCtxImpl, 

        WHA::KMibTemplateFrame, 

        mibLength,

        mib );