/*

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

*

*/

/*

* %version: 19 %

*/

#include "config.h"

#include "umacdot11idlescanningmode.h"

#include "umacscanfsmcntx.h"

#include "UmacContextImpl.h"

#include "UmacWsaWriteMib.h"

#include "UmacWsaScan.h"

#include "umacwhastopscan.h"

#include "umacwhatodot11typeconverter.h"

#ifndef NDEBUG

const TInt8 WlanDot11IdleScanningMode::iName[] = "dot11-idlescanningmode";

const TUint8 WlanDot11IdleScanningMode::iStateName

    [ESTATEMAX][KMaxStateStringLength] = 

    {

        {"EINIT"}, 

        {"ESETSLEEPMODE"}, 

        {"EEXECUTESCANFSM"},

        {"ECONTINUEDOT11TRAVERSE"}

    };

const TUint8 WlanDot11IdleScanningMode::iEventName

    [EEVENTMAX][KMaxEventStringLength] = 

    {

        {"ESTATEENTRY"}, 

        {"ETXCOMPLETE"},

        {"ESTARTSCANNINGMODE"},

        {"ESCANMODERUNNING"},

        {"ESTOPSCANNINGMODE"},

        {"ESCANNINGMODEEXIT"},

        {"EABORT"}

    };

#endif

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

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

// 

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

//

WlanDot11IdleScanningMode::~WlanDot11IdleScanningMode() 

    {

    iCtxImpl = NULL;

    iChannels = NULL;

    iSSID = NULL;

    iPimpl = NULL;

    }

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

// 

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

//

void WlanDot11IdleScanningMode::Set( 

    WlanContextImpl& aCtxImpl )

    {

    iCtxImpl = &aCtxImpl;

    }

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

// 

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

//

void WlanDot11IdleScanningMode::Set( 

    TScanMode aMode,                    

    const TSSID& aSSID,                 

    TUint32 aScanRate,                    

    SChannels& aChannels,

    TUint32 aMinChannelTime,            

    TUint32 aMaxChannelTime,

    TBool aSplitScan )    

    {

    // we can store pointers as oid parameters are guaranteed to be valid 

    // to the point the corresponding completion method is called

    iMode = aMode;

    iSSID = &aSSID;

    iScanRate = aScanRate;

    iChannels = &aChannels;

    iMinChannelTime = aMinChannelTime;

    iMaxChannelTime = aMaxChannelTime;    

    iSplitScan = aSplitScan;    

    }

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

// The internal state transition method.

// It is guaranteed by the FSM framework that no WHA command is pending

// when this method is entered

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

//

void WlanDot11IdleScanningMode::ChangeInternalState( 

    WlanContextImpl& aCtxImpl, 

    TState aNewState )

    {

    iState = aNewState;

    Fsm( aCtxImpl, ESTATEENTRY );

    }

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

// The event dispatcher method.

// It is guaranteed by the FSM framework that no WHA command is pending

// when this method is entered

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

//

void WlanDot11IdleScanningMode::Fsm( 

    WlanContextImpl& aCtxImpl, 

    TEvent aEvent )

    {

    OsTracePrint( KScan, 

        (TUint8*)("UMAC * dot11-idlescanningmode * FSM EVENT") );

#ifndef NDEBUG

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

    OsTracePrint( KScan, iEventName[aEvent] );

    OsTracePrint( KScan, (TUint8*)("state:"));

    OsTracePrint( KScan, iStateName[iState] );

#endif

    switch ( aEvent )

        {

        case ESTATEENTRY:

            OnStateEntryEvent( aCtxImpl );

            break;

        case ETXCOMPLETE:

            OnTxCompleteEvent( aCtxImpl );

            break;

        case ESTARTSCANNINGMODE:

            OnStartScanningModeEvent( aCtxImpl );

            break;

        case ESCANMODERUNNING:

            OnScanModeRunningEvent( aCtxImpl );

            break;

        case ESTOPSCANNINGMODE:

            OnStopScanningModeEvent( aCtxImpl );

            break;

        case ESCANNINGMODEEXIT:

            OnScanningModeExitEvent( 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;

        }

    }

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

// Handler for the event.

// It is guaranteed by the FSM framework that no WHA command is pending

// when this method is entered

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

//

void WlanDot11IdleScanningMode::OnStateEntryEvent( 

    WlanContextImpl& aCtxImpl )

    {

    switch ( iState )

        {

        case EINIT:

            iPimpl = static_cast<WlanScanFsmCntx*>

                (os_alloc( sizeof(WlanScanFsmCntx) ));

            if ( iPimpl )

                {

                // allocation success

                new (iPimpl) WlanScanFsmCntx( *this );

                // start fsm traversal

                if ( aCtxImpl.Reassociate() )

                    {

                    // a roaming case

                    ChangeInternalState( aCtxImpl, EEXECUTESCANFSM );

                    }

                else

                    {

                    // not a roaming case

                    ChangeInternalState( aCtxImpl, ESETSLEEPMODE );

                    }

                }

            else

                {

                // allocation failure

                Fsm( aCtxImpl, EABORT );

                }

            break;

        case ESETSLEEPMODE:

            SetSleepMode( aCtxImpl );

            break;

        case EEXECUTESCANFSM:

            ExecuteScanFsm( aCtxImpl );

            break;

        case ECONTINUEDOT11TRAVERSE:

            ContinueDot11StateTraversal( aCtxImpl );

            break;

        default:

            // catch internal FSM programming error

#ifndef NDEBUG

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

            OsTracePrint( KErrorLevel, iStateName[iState] );

#endif

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

                (TUint8*)(WLAN_FILE), __LINE__ );

            break;

        }

    }

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

// Handler for the event.

// It is guaranteed by the FSM framework that no WHA command is pending

// when this method is entered

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

//

void WlanDot11IdleScanningMode::OnTxCompleteEvent( 

    WlanContextImpl& aCtxImpl )

    {

    switch ( iState )

        {

        case ESETSLEEPMODE:

            ChangeInternalState( aCtxImpl, EEXECUTESCANFSM );

            break;

        case EEXECUTESCANFSM:

            // we are running the scan fsm 

            // and we have nothing to do here

            break;

        default:

            // catch internal FSM programming error

#ifndef NDEBUG

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

            OsTracePrint( KErrorLevel, iStateName[iState] );

#endif

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

                (TUint8*)(WLAN_FILE), __LINE__ );

            break;

        }

    }

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

// Handler for the event.

// It is guaranteed by the FSM framework that no WHA command is pending

// when this method is entered

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

//

void WlanDot11IdleScanningMode::OnStartScanningModeEvent( 

    WlanContextImpl& aCtxImpl )

    {

    // start the scanning mode

    // convert scan parameters to WHA types

    // Note that we need to deallocate the memory from whaChannels

    // - which is allocated in ConvertToWhaTypes() - when we are done

    WHA::SSSID* wha_ssid = 

        static_cast<WHA::SSSID*>(os_alloc( sizeof(WHA::SSSID) )); 

    if ( !wha_ssid )

        {

        // memory allocation failue; that's fatal

        Fsm( aCtxImpl, EABORT );

        return;

        }

    WHA::SChannels* wha_channels( NULL );

    TUint8 wha_channelcount( 0 );

    if ( !(WlanWhaToDot11TypeConverter::ConvertToWhaTypes(       

        aCtxImpl, 

        iSSID, 

        *wha_ssid, 

        iChannels,

        iMinChannelTime,

        iMaxChannelTime,

        wha_channels, 

        wha_channelcount )) )

        {

        // memory allocation failue; that's fatal

        os_free( wha_ssid );

        Fsm( aCtxImpl, EABORT );

        }

    else

        {

        // start the scanning process

        const TUint8 KNbrOfProbeReqsPerCh = 2;

        const TUint8 KNoProbeReqs = 0;

        const TUint8 KNbrOfSsids = 1;

        const TUint8 KNoSsids = 0;

        // 1st set the context

        aCtxImpl.WsaScan().Set( 

            aCtxImpl,

            iScanRate,

            iChannels->iBand,

            wha_channelcount,

            wha_channels,

            WHA::EFgScan,

            (iMode == EActiveScan) ? KNbrOfProbeReqsPerCh : KNoProbeReqs,

            iSplitScan,

            wha_ssid->iSSIDLength ? KNbrOfSsids : KNoSsids,

            wha_ssid );

        // change global state: entry procedure triggers action

        ChangeState( aCtxImpl, 

            *this,              // prev state

            aCtxImpl.WsaScan()  // next state

            );

        // as the parameters have been supplied we can now deallocate

        os_free( wha_ssid );

        os_free( wha_channels );                                    

        }

    }

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

// Handler for the event.

// It is guaranteed by the FSM framework that no WHA command is pending

// when this method is entered

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

//

void WlanDot11IdleScanningMode::OnScanModeRunningEvent( 

    WlanContextImpl& aCtxImpl ) const

    {

    // complete the scan request

    OsTracePrint( KScan, (TUint8*)

        ("UMAC: WlanDot11IdleScanningMode::OnScanModeRunningEvent: Complete scan request") );

    OnOidComplete( aCtxImpl );            

    }

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

// Handler for the event.

// It is guaranteed by the FSM framework that no WHA command is pending

// when this method is entered

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

//

void WlanDot11IdleScanningMode::OnStopScanningModeEvent( 

    WlanContextImpl& aCtxImpl )

    {

    // change global state: entry procedure triggers action

    ChangeState( aCtxImpl, 

        *this,                  // prev state

        aCtxImpl.WhaStopScan()  // next state

        );

    }

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

// Handler for the event.

// It is guaranteed by the FSM framework that no WHA command is pending

// when this method is entered

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

//

void WlanDot11IdleScanningMode::OnScanningModeExitEvent( 

    WlanContextImpl& aCtxImpl )

    {

    // scanning mode has stopped and so can we

    // request the next state (dot11IdleState) to inform the mgmt client about 

    // scan completion upon state entry

    aCtxImpl.iStates.iIdleState.CompleteScanUponEntry();

    ChangeInternalState( aCtxImpl, ECONTINUEDOT11TRAVERSE );

    }

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

// simulate macnotresponding error

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

//

void WlanDot11IdleScanningMode::OnAbortEvent( 

    WlanContextImpl& aCtxImpl )

    {

    OsTracePrint( KWarningLevel, 

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

    DoErrorIndication( aCtxImpl, WHA::KErrorMacNotResponding );

    }

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

// 

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

//

void WlanDot11IdleScanningMode::SetSleepMode( 

    WlanContextImpl& aCtxImpl )

    {

    WHA::SsleepMode* mib 

        = static_cast<WHA::SsleepMode*>

        (os_alloc( sizeof( WHA::SsleepMode ) )); 

    if ( !mib )

        {

        // this is fatal

        Fsm( aCtxImpl, EABORT );

        return;

        }

    mib->iMode = WHA::KPowerDownMode;

    WlanWsaWriteMib& wha_cmd = aCtxImpl.WsaWriteMib();

    wha_cmd.Set( 

        aCtxImpl, WHA::KMibSleepMode, 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 WlanDot11IdleScanningMode::ExecuteScanFsm( 

    WlanContextImpl& /*aCtxImpl*/ )

    {

    // start scan fsm

    iPimpl->Current().StartScanningMode( *iPimpl );

    }

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

// 

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

//

void WlanDot11IdleScanningMode::ContinueDot11StateTraversal( 

    WlanContextImpl& aCtxImpl )

    {

    // return back to dot11idle    

    ChangeState( aCtxImpl, 

        *this,                          // prev state

        aCtxImpl.iStates.iIdleState     // next state

        );

    }

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

// Handler for WHA command response event.

// It is guaranteed by the global protocol fsm framework that no WHA command is 

// pending when this method is entered

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

//

void WlanDot11IdleScanningMode::OnWhaCommandResponse( 

    WlanContextImpl& aCtxImpl, 

    WHA::TCommandId aCommandId, 

    WHA::TStatus /*aStatus*/,

    const WHA::UCommandResponseParams& /*aCommandResponseParams*/,

    TUint32 /*aAct*/ )

    {

    if ( aCommandId == WHA::EScanCommandResponse )

        {

        OsTracePrint( KScan, (TUint8*)("UMAC * OnScanningModeStarted"));

        // morph event to the scan fsm

        iPimpl->Current().OnScanningModeStarted( *iPimpl );

        }

    else if ( aCommandId == WHA::EStopScanResponse )

        {

        // complete the stop scan request

        OsTracePrint( KScan, (TUint8*)

            ("UMAC: WlanDot11IdleScanningMode::OnWhaCommandResponse: complete stop scan request"));        

        OnOidComplete( aCtxImpl );

        }

    else

        {

        // has to be the write mib command response.

        // We have nothing to do here

        }

    }

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

// Handler for WHA command completion event.

// It is guaranteed by the global protocol fsm framework that no WHA command is 

// pending when this method is entered

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

//

TBool WlanDot11IdleScanningMode::CommandComplete( 

    WlanContextImpl& /*aCtxImpl*/, 

    WHA::TCompleteCommandId aCompleteCommandId, 

    WHA::TStatus /*aStatus*/,

    const WHA::UCommandCompletionParams& /*aCommandCompletionParams*/ )

    {

    if ( aCompleteCommandId != WHA::EScanComplete )

        {

        // implementation error as this can be the only one

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

        }

    OsTracePrint( KScan, (TUint8*)("UMAC * OnScanningModeStopped"));

    // morph event to scan fsm

    iPimpl->Current().OnScanningModeStopped( *iPimpl );

    // as scanning mode has ended we will change dot11 state.

    // Signal it to caller

    return ETrue;

    }

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

// 

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

//

TAny* WlanDot11IdleScanningMode::RequestForBuffer( 

    WlanContextImpl& aCtxImpl, 

    TUint16 aLength )

    {

    return aCtxImpl.GetRxBuffer( aLength );