/*

* 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 WlanDot11MibDefaultConfigure class

*

*/

/*

* %version: 26 %

*/

#include "config.h"

#include "UmacDot11MibDefaultConfigure.h"

#include "wha_mibDefaultvalues.h"

#include "umacwhatodot11typeconverter.h"

#include "UmacWsaWriteMib.h"

#include "UmacContextImpl.h"

const TUint KAllocLen = 512; 

#ifndef NDEBUG

const TInt8 WlanDot11MibDefaultConfigure::iName[] 

    = "dot11-mibdefaultconfigure";

const TUint8 WlanDot11MibDefaultConfigure::iStateName

    [ESTATEMAX][KMaxStateStringLength] = 

    {

        {"EINIT"}, 

        {"ESETDOT11MAXRECEIVELIFETIME"}, 

        {"ESETDOT11SLOTTIME"},

        {"ESETDOT11GROUPADDRSTABLE"},

        {"ESETDOT11WEPDEFAULTKEY"},

        {"ESETDOT11CURRENTTXPOWERLEVEL"},

        {"ESETDOT11RTSTHRESHOLD"},

        {"ESETCTSTOSELF"},

        {"ESETARPIPADDRSTABLE"},

        {"ESETPROBEREQUESTTEMPLATE"},

        {"ESETRXFILTER"},

        {"ESETBEACONFILTERIETABLE"},

        {"ESETBEACONFILTERENABLE"},

        {"ESETWLANWAKEUPINTERVAL"},

        {"ESETBEACONLOSTCOUNT"},

        {"ESETRCPITHRESHOLD"},

        {"ESETTXRATEPOLICY"},

        {"ESETHTCAPABILITIES"},

        {"ESETHTBSSOPERATION"},

        {"ESETHTSECONDARYBEACON"},

        {"ESETHTBLOCKACKCONFIGURE"},

        {"ECONTINUEDOT11TRAVERSE"}

    };

const TUint8 WlanDot11MibDefaultConfigure::iEventName

    [EEVENTMAX][KMaxEventStringLength] = 

    {

        {"ESTATEENTRY"}, {"ETXCOMPLETE"}, {"EABORT"}

    };

#endif

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

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

// 

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

//

WlanDot11MibDefaultConfigure::~WlanDot11MibDefaultConfigure()

    {

    iMemory = NULL;

    }

#ifndef NDEBUG 

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

// 

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

//

const TInt8* WlanDot11MibDefaultConfigure::GetStateName( 

    TUint8& aLength ) const

    {

    aLength = sizeof( iName );

    return iName;

    }

#endif

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

// WlanDot11MibDefaultConfigure::Entry

// (other items were commented in a header).

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

//

void WlanDot11MibDefaultConfigure::Entry( 

    WlanContextImpl& aCtxImpl )

    {

    if ( aCtxImpl.WsaCmdActive() )

        {

        // sanity checking code

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

            (TUint8*)(WLAN_FILE), __LINE__ );

        }

    // we don't want to do event dispatching here as we want to set the

    // mib default values without interruptions 

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

        }

    }

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

// WlanDot11MibDefaultConfigure::Exit

// (other items were commented in a header).

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

//

void WlanDot11MibDefaultConfigure::Exit( 

    WlanContextImpl& /*aCtxImpl*/ )

    {

    // we are traversing to a new dot11 state 

    // make sure we don't generate a memory leakage

    os_free( iMemory );

    iState = EINIT; 

    }

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

// WlanDot11MibDefaultConfigure::ChangeInternalState

// (other items were commented in a header).

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

//

void WlanDot11MibDefaultConfigure::ChangeInternalState( 

    WlanContextImpl& aCtxImpl, 

    TState aNewState )

    {

    iState = aNewState;

    Fsm( aCtxImpl, ESTATEENTRY );

    }

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

// WlanDot11MibDefaultConfigure::Fsm

// (other items were commented in a header).

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

//

void WlanDot11MibDefaultConfigure::Fsm( 

    WlanContextImpl& aCtxImpl, 

    TEvent aEvent )

    {

    OsTracePrint( KUmacDetails, 

        (TUint8*)("UMAC: WlanDot11MibDefaultConfigure::Fsm(): FSM EVENT") );

#ifndef NDEBUG

    OsTracePrint( 

        KUmacDetails, 

        (TUint8*)("UMAC: WlanDot11MibDefaultConfigure::Fsm(): event:"));

    OsTracePrint( KUmacDetails, iEventName[aEvent] );

    OsTracePrint( 

        KUmacDetails, 

        (TUint8*)("UMAC: WlanDot11MibDefaultConfigure::Fsm(): state:"));

    OsTracePrint( KUmacDetails, iStateName[iState] );

#endif

    switch ( aEvent )

        {

        case ESTATEENTRY:

            OnStateEntryEvent( aCtxImpl );

            break;

        case ETXCOMPLETE:

            OnTxCompleteEvent( aCtxImpl );

            break;

        case EABORT:

            OnAbortEvent( aCtxImpl );

            break;

        default:

            // catch internal FSM programming error

            OsTracePrint( 

                KErrorLevel, 

                (TUint8*)("UMAC: WlanDot11MibDefaultConfigure::Fsm(): event: %d"), aEvent);        

            OsAssert( 

                (TUint8*)("UMAC: WlanDot11MibDefaultConfigure::Fsm(): panic"), 

                (TUint8*)(WLAN_FILE), __LINE__ );

            break;

        }

    }

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

// WlanDot11MibDefaultConfigure::OnStateEntryEvent

// Handler for state entry event.

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

// when this method is entered

// (other items were commented in a header).

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

//

void WlanDot11MibDefaultConfigure::OnStateEntryEvent( 

    WlanContextImpl& aCtxImpl )

    {

    switch ( iState )

        {

        case EINIT:

            iMemory = os_alloc( KAllocLen );

            if ( iMemory )

                {

                // start the FSM traversal

                ChangeInternalState( aCtxImpl, 

                    ESETDOT11MAXRECEIVELIFETIME );            

                }

            else

                {

                // allocation failure

                Fsm( aCtxImpl, EABORT );

                }

            break;

        case ESETDOT11MAXRECEIVELIFETIME:

            SetDot11MaxReceiveLifeTime( aCtxImpl );

            break;

        case ESETDOT11SLOTTIME:

            SetDot11SlotTime( aCtxImpl );

            break;

        case ESETDOT11GROUPADDRSTABLE:

            SetDot11GroupAddrsTable( aCtxImpl );

            break;

        case ESETDOT11WEPDEFAULTKEY:

            SetDot11WepDefaultKey( aCtxImpl );

            break;

        case ESETDOT11CURRENTTXPOWERLEVEL:

            SetDot11CurrentTxPowerLevel( aCtxImpl );

            break;

        case ESETDOT11RTSTHRESHOLD:

            SetDot11RtsThreshold( aCtxImpl );

            break;

        case ESETCTSTOSELF:

            SetCtsToSelf( aCtxImpl );

            break;

        case ESETARPIPADDRSTABLE:

            SetArpIpAddrsTable( aCtxImpl );

            break;

        case ESETPROBEREQUESTTEMPLATE:

            SetProbeRequestTemplate( aCtxImpl );

            break;

        case ESETRXFILTER:

            SetRxFilter( aCtxImpl );

            break;

        case ESETBEACONFILTERIETABLE:

            SetBeaconFilterIeTable( aCtxImpl );

            break;

        case ESETBEACONFILTERENABLE:

            SetBeaconFilterEnable( aCtxImpl );

            break;

        case ESETWLANWAKEUPINTERVAL:

            SetWlanWakeupInterval( aCtxImpl );

            break;

        case ESETBEACONLOSTCOUNT:

            SetBeaconLostCount( aCtxImpl );

            break;

        case ESETRCPITHRESHOLD:

            SetRcpiThreshold( aCtxImpl );

            break;

        case ESETTXRATEPOLICY:

            SetTxRatePolicy( aCtxImpl );

            break;

        case ESETHTCAPABILITIES:

            SetHtCapabilities( aCtxImpl );

            break;

        case ESETHTBSSOPERATION:

            SetHtBssOperation( aCtxImpl );

            break;

        case ESETHTSECONDARYBEACON:

            SetHtSecondaryBeacon( aCtxImpl );

            break;

        case ESETHTBLOCKACKCONFIGURE:

            SetHtBlockAckConfigure( aCtxImpl );

            break;

        case ECONTINUEDOT11TRAVERSE:

            // our dot11 transition is fixed and we shall take it

            // change global dot11 state: entry procedure triggers action

            ChangeState( aCtxImpl,              

                *this,                          // prev state

                aCtxImpl.iStates.iIdleState     // next state

                );

            break;

        default:

            // catch internal FSM programming error

            OsTracePrint( KErrorLevel, (TUint8*)

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

                iState);        

            OsAssert( (TUint8*)

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

                (TUint8*)(WLAN_FILE), __LINE__ );

            break;

        }

    }

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

// Handler for tx complete event.

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

// when this method is entered

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

//

void WlanDot11MibDefaultConfigure::OnTxCompleteEvent( 

    WlanContextImpl& aCtxImpl )

    {

    switch ( iState )

        {

        case ESETDOT11MAXRECEIVELIFETIME:

            if ( aCtxImpl.WHASettings().iCapability 

                & WHA::SSettings::KDot11SlotTime )

                {

                // supported

                ChangeInternalState( 

                    aCtxImpl, ESETDOT11SLOTTIME );

                }

            else

                {

                OsTracePrint( KWarningLevel, (TUint8*)

                    ("UMAC * dot11-mibdefaultconfigure"));

                OsTracePrint( KWarningLevel, (TUint8*)

                    ("no support for dot11slottime mib skipping"));

                ChangeInternalState( aCtxImpl, 

                    ESETDOT11GROUPADDRSTABLE );

                }

            break;

        case ESETDOT11SLOTTIME:

            ChangeInternalState( aCtxImpl, 

                ESETDOT11GROUPADDRSTABLE );

            break;

        case ESETDOT11GROUPADDRSTABLE:

            ChangeInternalState( aCtxImpl, 

                ESETDOT11WEPDEFAULTKEY );

            break;

        case ESETDOT11WEPDEFAULTKEY:

            ChangeInternalState( aCtxImpl, 

                ESETDOT11CURRENTTXPOWERLEVEL );

            break;

        case ESETDOT11CURRENTTXPOWERLEVEL:

            ChangeInternalState( aCtxImpl, 

                ESETDOT11RTSTHRESHOLD );

            break;

        case ESETDOT11RTSTHRESHOLD:

            ChangeInternalState( aCtxImpl, 

                ESETCTSTOSELF );

            break;

        case ESETCTSTOSELF:

            ChangeInternalState( aCtxImpl, 

                ESETARPIPADDRSTABLE );

            break;

        case ESETARPIPADDRSTABLE:

            ChangeInternalState( aCtxImpl, 

                ESETPROBEREQUESTTEMPLATE );

            break;

        case ESETPROBEREQUESTTEMPLATE:

            ChangeInternalState( aCtxImpl, 

                ESETRXFILTER );

            break;

        case ESETRXFILTER:

            ChangeInternalState( aCtxImpl, 

                ESETBEACONFILTERIETABLE );

            break;

        case ESETBEACONFILTERIETABLE:

            ChangeInternalState( aCtxImpl, 

                ESETBEACONFILTERENABLE );

            break;

        case ESETBEACONFILTERENABLE:

            ChangeInternalState( aCtxImpl, 

                ESETWLANWAKEUPINTERVAL );

            break;

        case ESETWLANWAKEUPINTERVAL:

            ChangeInternalState( aCtxImpl, 

                ESETBEACONLOSTCOUNT );

            break;

        case ESETBEACONLOSTCOUNT:

            ChangeInternalState( aCtxImpl, 

                ESETRCPITHRESHOLD );

            break;

        case ESETRCPITHRESHOLD:

            ChangeInternalState( aCtxImpl, 

                ESETTXRATEPOLICY );

            break;

        case ESETTXRATEPOLICY:

            if ( aCtxImpl.WHASettings().iCapability 

                & WHA::SSettings::KHtOperation )

                {

                // supported

                ChangeInternalState( 

                    aCtxImpl, ESETHTCAPABILITIES );

                }

            else

                {

                // HT not supported, so we will skip setting the HT related

                // MIBs

                OsTracePrint( KWarningLevel, (TUint8*)

                    ("UMAC: WlanDot11MibDefaultConfigure::OnTxCompleteEvent: no HT support, skipping HT related mibs"));

                ChangeInternalState( aCtxImpl, 

                    ECONTINUEDOT11TRAVERSE );

                }

            break;

        case ESETHTCAPABILITIES:

            ChangeInternalState( aCtxImpl, 

                ESETHTBSSOPERATION );

            break;

        case ESETHTBSSOPERATION:

            ChangeInternalState( aCtxImpl, 

                ESETHTSECONDARYBEACON );

            break;

        case ESETHTSECONDARYBEACON:

            ChangeInternalState( aCtxImpl, 

                ESETHTBLOCKACKCONFIGURE );            

            break;

        case ESETHTBLOCKACKCONFIGURE:

            ChangeInternalState( aCtxImpl, 

                ECONTINUEDOT11TRAVERSE );            

            break;

        default:

            // catch internal FSM programming error

            OsTracePrint( 

                KErrorLevel, 

                (TUint8*)("UMAC: WlanDot11MibDefaultConfigure::OnTxCompleteEvent(): state: %d"), 

                iState);        

            OsAssert( 

                (TUint8*)("UMAC: UMAC: WlanDot11MibDefaultConfigure::OnTxCompleteEvent(): panic"), 

                (TUint8*)(WLAN_FILE), __LINE__ );

            break;

        }

    }

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

// WlanDot11MibDefaultConfigure::OnAbortEvent

// simulate macnotresponding error

// (other items were commented in a header).

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

//

void WlanDot11MibDefaultConfigure::OnAbortEvent( 

    WlanContextImpl& aCtxImpl )

    {

    // memory is released by Exit() method

    OsTracePrint( KWarningLevel, 

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

    DoErrorIndication( aCtxImpl, WHA::KErrorMacNotResponding );

    }

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

// WlanDot11MibDefaultConfigure::SetDot11MaxReceiveLifeTime

// (other items were commented in a header).

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

//

void WlanDot11MibDefaultConfigure::SetDot11MaxReceiveLifeTime( 

    WlanContextImpl& aCtxImpl )

    {

    OsTracePrint( KUmacDetails, 

        (TUint8*)("UMAC: WlanDot11MibDefaultConfigure::SetDot11MaxReceiveLifeTime()") );

    WHA::Sdot11MaxReceiveLifeTime* mib 

        = static_cast<WHA::Sdot11MaxReceiveLifeTime*>(iMemory);

    *mib = WHA::KDot11MaxReceiveLifeTimeMibDefault;

    WlanWsaWriteMib& wsa_cmd = aCtxImpl.WsaWriteMib();

    wsa_cmd.Set( 

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

    // change global state: entry procedure triggers action

    ChangeState( aCtxImpl, 

        *this,              // prev state

        wsa_cmd             // next state

        );   

    }

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

// WlanDot11MibDefaultConfigure::SetDot11SlotTime

// (other items were commented in a header).

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

//

void WlanDot11MibDefaultConfigure::SetDot11SlotTime( 

    WlanContextImpl& aCtxImpl )

    {

    OsTracePrint( KUmacDetails, 

        (TUint8*)("UMAC: WlanDot11MibDefaultConfigure::SetDot11SlotTime()") );

    WHA::Sdot11SlotTime* mib

        = static_cast<WHA::Sdot11SlotTime*>(iMemory);

    *mib = WHA::KDot11SlotTimeMibDefault;

    WlanWsaWriteMib& wsa_cmd = aCtxImpl.WsaWriteMib();

    wsa_cmd.Set( 

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

    // change global state: entry procedure triggers action

    ChangeState( aCtxImpl, 

        *this,              // prev state

        wsa_cmd             // next state

        );   

    }

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

// WlanDot11MibDefaultConfigure::SetDot11GroupAddrsTable

// (other items were commented in a header).

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

//

void WlanDot11MibDefaultConfigure::SetDot11GroupAddrsTable( 

    WlanContextImpl& aCtxImpl )

    {

    OsTracePrint( KUmacDetails, 

        (TUint8*)("UMAC: WlanDot11MibDefaultConfigure::SetDot11GroupAddrsTable()") );

    WHA::Sdot11GroupAddressesTable* mib

        = static_cast<WHA::Sdot11GroupAddressesTable*>(iMemory);

    *mib = WHA::KDot11GroupAddressesTableMibDefault;

    WlanWsaWriteMib& wsa_cmd = aCtxImpl.WsaWriteMib();

    wsa_cmd.Set( 

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