/*

* Copyright (c) 2007-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 WlanConfigureTxAutoRatePolicy class

*

*/

/*

* %version: 6 %

*/

#include "config.h"

#include "umacconfiguretxautoratepolicy.h"

#include "UmacContextImpl.h"

#include "UmacWsaWriteMib.h"

#ifndef RD_WLAN_DDK

#include <wha_mib.h>

#else

#include <wlanwha_mib.h>

#endif

#ifndef NDEBUG

const TInt8 WlanConfigureTxAutoRatePolicy::iName[] 

    = "whacomplex-configuretxautoratepolicy";

const TUint8 WlanConfigureTxAutoRatePolicy::iStateName

    [ESTATEMAX][KMaxStateStringLength] = 

    {

        {"EINIT"}, 

        {"ESETAUTORATEPOLICY"},

        {"EFINIT"}

    };

const TUint8 WlanConfigureTxAutoRatePolicy::iEventName

    [EEVENTMAX][KMaxEventStringLength] = 

    {

        {"ESTATEENTRY"}, 

        {"ETXCOMPLETE"},

        {"EABORT"}

    };

#endif // !NDEBUG

// length of txAutoRatePolicy MIB

const TUint16 KtxAutoRatePolicyMibLen = sizeof( WHA::StxAutoRatePolicy );

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

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

// 

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

//

WlanConfigureTxAutoRatePolicy::WlanConfigureTxAutoRatePolicy() : 

     iState ( EINIT ),

     iCompleteMgmtRequest ( EFalse ),

     iTxAutoRatePolicyMib ( NULL ),

     iNumberOfPolicyClassesToConfigure ( 0 ),

     iRatePolicyClass ( 0 )

    {

    }

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

// 

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

//

WlanConfigureTxAutoRatePolicy::~WlanConfigureTxAutoRatePolicy() 

    { 

    iTxAutoRatePolicyMib = NULL;

    }

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

// 

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

//

void WlanConfigureTxAutoRatePolicy::Set( TBool aCompleteMgmtRequest  )

    {

    iCompleteMgmtRequest = aCompleteMgmtRequest;

    }

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

// 

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

//

void WlanConfigureTxAutoRatePolicy::Fsm( 

    WlanContextImpl& aCtxImpl, 

    TEvent aEvent )

    {

#ifndef NDEBUG

    OsTracePrint( KUmacDetails, (TUint8*)

        ("UMAC: WlanConfigureTxAutoRatePolicy::Fsm: event:"));

    OsTracePrint( KUmacDetails, iEventName[aEvent] );

    OsTracePrint( KUmacDetails, (TUint8*)

        ("UMAC: WlanConfigureTxAutoRatePolicy::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

#ifndef NDEBUG

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

            OsTracePrint( KErrorLevel, iEventName[aEvent] );                

#endif 

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

        }

    }

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

// 

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

//

void WlanConfigureTxAutoRatePolicy::OnStateEntryEvent( 

    WlanContextImpl& aCtxImpl )

    {

    switch ( iState )

        {

        case EINIT:

            // determine the number of rate policy classes to set

            iNumberOfPolicyClassesToConfigure = 

                (aCtxImpl.RatePolicy()).numOfPolicyObjects;

            OsTracePrint( KUmacDetails, (TUint8*)

                ("UMAC: WlanConfigureTxAutoRatePolicy::OnStateEntryEvent: nbr of policy classes to configure: %d"),

                iNumberOfPolicyClassesToConfigure );

            // rate policy class IDs start from 1, so that's the 1st to 

            // configure

            iRatePolicyClass = 1;

            // allocate memory for the MIB to write

            iTxAutoRatePolicyMib = 

                static_cast<WHA::StxAutoRatePolicy*>(

                    os_alloc( KtxAutoRatePolicyMibLen ) ); 

            if ( iTxAutoRatePolicyMib )

                {

                // start the FSM traversal

                ChangeInternalState( aCtxImpl, ESETAUTORATEPOLICY );

                }

            else

                {

                // allocation failure, abort processing

                Fsm( aCtxImpl, EABORT );                

                }

            break;

        case ESETAUTORATEPOLICY:

            SetAutoRatePolicy( aCtxImpl );                

            break;

        case EFINIT:

            // fsm execution complete. 

            // complete WLAN Mgmt Client request, if necessary

            if ( iCompleteMgmtRequest )

                {

                OnOidComplete( aCtxImpl, KErrNone );

                }

            // Traverse back to history state

            TraverseToHistoryState( aCtxImpl );

            break;

        default:

            // cath internal FSM programming error

#ifndef NDEBUG

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

            OsTracePrint( KErrorLevel, iStateName[iState] );

#endif 

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

        }

    }

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

// 

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

//

void WlanConfigureTxAutoRatePolicy::OnTxCompleteEvent( 

    WlanContextImpl& aCtxImpl )

    {

    switch ( iState )

        {

        case ESETAUTORATEPOLICY:

            // one (more) rate policy class has been set

            ++iRatePolicyClass;

            if ( iRatePolicyClass <= iNumberOfPolicyClassesToConfigure )

                {

                // we haven't configured all the rate policy classes, yet

                // so proceed with the next one by re-entering the current

                // internal state

                ChangeInternalState( aCtxImpl, ESETAUTORATEPOLICY );

                }

            else

                {

                // all rate policy classes have been set. We are done

                ChangeInternalState( aCtxImpl, EFINIT );                

                }

            break;

        default:

            // cath internal FSM programming error

#ifndef NDEBUG

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

            OsTracePrint( KErrorLevel, iStateName[iState] );

#endif             

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

        }

    }

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

// simulate macnotresponding error

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

//

void WlanConfigureTxAutoRatePolicy::OnAbortEvent( 

    WlanContextImpl& aCtxImpl )

    {

    OsTracePrint( KWarningLevel, 

        (TUint8*)("UMAC: WlanConfigureTxAutoRatePolicy::OnAbortEvent") );

    DoErrorIndication( aCtxImpl, WHA::KErrorMacNotResponding );

    }

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

// 

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

//

void WlanConfigureTxAutoRatePolicy::ChangeInternalState( 

    WlanContextImpl& aCtxImpl, 

    TState aNewState )

    {

    iState = aNewState;

    Fsm( aCtxImpl, ESTATEENTRY );

    }

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

// 

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

//

void WlanConfigureTxAutoRatePolicy::SetAutoRatePolicy( 

    WlanContextImpl& aCtxImpl )

    {

    OsTracePrint( KUmacDetails, (TUint8*)

        ("UMAC: WlanConfigureTxAutoRatePolicy::SetAutoRatePolicy") );

    // retrieve reference to the stored rate policy information

    const TTxRatePolicy& ratePolicy ( aCtxImpl.RatePolicy() );

    // ... and to the stored auto rate policy

    TTxAutoRatePolicy& autoRatePolicy ( aCtxImpl.AutoRatePolicy() );

    // ... and to the stored HT MCS policy information

    const THtMcsPolicy& htMcsPolicy ( aCtxImpl.HtMcsPolicy() );

    // 1st clear

    os_memset( iTxAutoRatePolicyMib, 0, KtxAutoRatePolicyMibLen );

    // set the mib contents. Note that because rate policy class IDs start from

    // 1 and array indexes from 0 we need to subtract one from the rate policy

    // class ID when accessing corresponding arrays

    iTxAutoRatePolicyMib->iBAndGRates = autoRatePolicy[iRatePolicyClass - 1];

    iTxAutoRatePolicyMib->iTxRateClassId = iRatePolicyClass;

    iTxAutoRatePolicyMib->iShortRetryLimit = 

        ratePolicy.txRateClass[iRatePolicyClass - 1].shortRetryLimit;

    iTxAutoRatePolicyMib->iLongRetryLimit = 

        ratePolicy.txRateClass[iRatePolicyClass - 1].longRetryLimit;

    os_memcpy( 

        iTxAutoRatePolicyMib->iMcsSet,

        &(htMcsPolicy[iRatePolicyClass - 1]),

        sizeof( WHA::THtMcsSet ) );

    WlanWsaWriteMib& whaCmd = aCtxImpl.WsaWriteMib();

    whaCmd.Set( 

        aCtxImpl, 

        WHA::KMibTxAutoRatePolicy, 

        KtxAutoRatePolicyMibLen, 

        iTxAutoRatePolicyMib );

    // change global state: entry procedure triggers action

    ChangeState( aCtxImpl, 

        *this,              // prev state

        whaCmd              // next state

        );           

    }

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

// 

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

//

void WlanConfigureTxAutoRatePolicy::Entry( 

    WlanContextImpl& aCtxImpl )

    {

    if ( aCtxImpl.WsaCmdActive() )

        {

        // sanity checking code

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

        }

    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 WlanConfigureTxAutoRatePolicy::Exit( 

    WlanContextImpl& /*aCtxImpl*/ )

    {

    iState = EINIT;

    os_free( iTxAutoRatePolicyMib );

    iTxAutoRatePolicyMib = NULL;

    }

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

// 

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

//

#ifndef NDEBUG 

const TInt8* WlanConfigureTxAutoRatePolicy::GetStateName( 

    TUint8& aLength ) const

    {

    aLength = sizeof( iName );

    return iName;

    }

#endif