/*

* Copyright (c) 2002-2010 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 Umac class

*

*/

/*

*/

#include "config.h"

#include "UmacContextImpl.h"

#include "Umac.h"

#include "umacoidmsg.h"

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

// 

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

//

Umac::Umac() : iPimpl( NULL ), iManagementRequestPending( EFalse )

    {

    os_memset( &iOidOutputData, 0, sizeof( iOidOutputData ) );

    }

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

// 

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

//

Umac::~Umac()

    {

    if ( iPimpl )

        {

        OsTracePrint( KInitLevel, 

            (TUint8*)("UMAC: Umac::~Umac(): deallocate internal impl"));        

        iPimpl->~WlanContextImpl();

        os_free( iPimpl );

        iPimpl = NULL;

        }

    }

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

// 

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

//

void Umac::OnTimeout( TWlanTimer aTimer )

    {

    if ( iPimpl->WsaCmdActive() ) // WHA layer in use 

        {

        // ...defer access

        switch ( aTimer )

            {

            case EWlanDefaultTimer:

                iPimpl->RegisterEvent( KTimeout );

                OsTracePrint( KEventDispatcher, 

                    (TUint8*)("UMAC: Umac::OnTimeout(): timeout event registered"));

                break;

            case EWlanVoiceCallEntryTimer:

                iPimpl->RegisterEvent( KVoiceCallEntryTimerTimeout );

                OsTracePrint( KEventDispatcher, 

                    (TUint8*)("UMAC: Umac::OnTimeout(): Voice Call Entry timer timeout event registered"));

                break;

            case EWlanNullTimer:

                iPimpl->RegisterEvent( KNullTimerTimeout );

                OsTracePrint( KEventDispatcher, 

                    (TUint8*)("UMAC: Umac::OnTimeout(): null timer timeout event registered"));

                break;

            case EWlanNoVoiceTimer:

                iPimpl->RegisterEvent( KNoVoiceTimerTimeout );

                OsTracePrint( KEventDispatcher, 

                    (TUint8*)("UMAC: Umac::OnTimeout(): No Voice timer timeout event registered"));

                break;

            case EWlanKeepAliveTimer:

                iPimpl->RegisterEvent( KKeepAliveTimerTimeout );

                OsTracePrint( KEventDispatcher, 

                    (TUint8*)("UMAC: Umac::OnTimeout(): Keep Alive timer timeout event registered"));

                break;

            case EWlanActiveToLightPsTimer:

                iPimpl->RegisterEvent( KActiveToLightPsTimerTimeout );

                OsTracePrint( KEventDispatcher, 

                    (TUint8*)("UMAC: Umac::OnTimeout(): Active to Light PS timer timeout event registered"));

                break;

            case EWlanLightPsToActiveTimer:

                iPimpl->RegisterEvent( KLightPsToActiveTimerTimeout );

                OsTracePrint( KEventDispatcher, 

                    (TUint8*)("UMAC: Umac::OnTimeout(): Light PS to Active timer timeout event registered"));

                break;

            case EWlanLightPsToDeepPsTimer:

                iPimpl->RegisterEvent( KLightPsToDeepPsTimerTimeout );

                OsTracePrint( KEventDispatcher, 

                    (TUint8*)("UMAC: Umac::OnTimeout(): Light PS to Deep PS timer timeout event registered"));

                break;

            default:

                OsTracePrint( KErrorLevel, 

                    (TUint8*)("UMAC: unknown timer: %d"), aTimer );

                OsAssert(

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

                    (TUint8*)(WLAN_FILE), __LINE__ );

            }        

        }

    else

        {

        // WHA layer not in use, proceed with the event handling immediately

        switch ( aTimer )

            {

            case EWlanDefaultTimer:

                iPimpl->CurrentState().OnTimeout( *iPimpl );        

                break;

            case EWlanVoiceCallEntryTimer:

                iPimpl->CurrentState().OnVoiceCallEntryTimerTimeout( *iPimpl );        

                break;

            case EWlanNullTimer:

                iPimpl->CurrentState().OnNullTimerTimeout( *iPimpl );        

                break;

            case EWlanNoVoiceTimer:

                iPimpl->CurrentState().OnNoVoiceTimerTimeout( *iPimpl );        

                break;

            case EWlanKeepAliveTimer:

                iPimpl->CurrentState().OnKeepAliveTimerTimeout( *iPimpl );        

                break;

            case EWlanActiveToLightPsTimer:

                iPimpl->CurrentState().OnActiveToLightPsTimerTimeout( *iPimpl );        

                break;

            case EWlanLightPsToActiveTimer:

                iPimpl->CurrentState().OnLightPsToActiveTimerTimeout( *iPimpl );        

                break;

            case EWlanLightPsToDeepPsTimer:

                iPimpl->CurrentState().OnLightPsToDeepPsTimerTimeout( *iPimpl );

                break;

            default:

                OsTracePrint( KErrorLevel, 

                    (TUint8*)("UMAC: unknown timer: %d"), aTimer );

                OsAssert(

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

                    (TUint8*)(WLAN_FILE), __LINE__ );

            }

        }

    }

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

// 

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

//

void Umac::OnDfc( TAny* aCtx )

    {

    if ( !(iPimpl->WsaCmdActive()) ) 

        {

        // WHA layer NOT in use 

        // this is an implementation error as we only use dfc callback

        // to break WHA command dispatching context, 

        // when we issue a synchronous command

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

        }

    iPimpl->CurrentState().OnDfc( aCtx );

    }

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

// 

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

//

void Umac::CompleteManagementCommand( 

    TInt aReason, 

    const TAny* aData,

    TUint32 aLengthInBytes )

    {

    if ( iManagementRequestPending )

        {

        // complete pending managemement request

        iManagementRequestPending = EFalse;

        iOidOutputData.iOidData = aData;

        iOidOutputData.iLengthOfDataInBytes = aLengthInBytes;

        OnOidCompleted( aReason, iOidOutputData );

        }

    else

        {

        // no request pending so there's nothing to do

        }

    }

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

// 

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

//

void Umac::AttachWsa( WHA::Wha* aWha )

    {

    OsTracePrint( KInitLevel, (TUint8*)("UMAC: Umac::AttachWsa(): 0x%08x"), 

        reinterpret_cast<TUint32>(aWha) );    

    // just forward to next layer 

    iPimpl->AttachWsa( aWha );

    }

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

// 

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

//

TBool Umac::Init()

    {

    OsTracePrint( KInitLevel, (TUint8*)("UMAC: Umac::Init()"));    

    TBool ret( EFalse );

    // deallocation of objecs allocated here is done in destructor

    iPimpl = static_cast<WlanContextImpl*>

        (os_alloc( sizeof(WlanContextImpl) ));

    if ( iPimpl )

        {

        new (iPimpl) WlanContextImpl( *this );

        ret = iPimpl->Initialize();

        }

    else

        {

        // failed

        OsTracePrint( KErrorLevel, 

            (TUint8*)("UMAC: Umac::Init(): alloc internal impl failure -> abort"));                

        }

    return ret;

    }

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

// 

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

//

void Umac::BootUp(

    const TUint8* aPda, 

    TUint32 aPdaLength,

    const TUint8* aFw, 

    TUint32 aFwLength )

    {

    OsTracePrint( KInitLevel, (TUint8*)("UMAC: * BootUp()"));  

    iManagementRequestPending = ETrue;

    iPimpl->BootUp( aPda, aPdaLength, aFw, aFwLength );

    }

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

// 

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

//

void Umac::FinitSystem()

    {

    OsTracePrint( KInitLevel, (TUint8*)("UMAC: * FinitSystem()"));  

    iManagementRequestPending = ETrue;

    }

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

// 

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

//

const TMacAddress& Umac::StationId() const

    {

    return iPimpl->iWlanMib.dot11StationId;

    }

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

// 

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

//

void Umac::SetTxOffset()

    {

    iPimpl->CurrentState().SetProtocolStackTxOffset( *iPimpl );

    }

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

// 

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

//

void Umac::TxProtocolStackData( 

    TDataBuffer& aDataBuffer,

    TBool aMore )

    {

    iPimpl->CurrentState().TxData( *iPimpl, aDataBuffer, aMore );

    }

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

// 

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

//

void Umac::GetFrameExtraSpaceForVendor( 

    TUint8& aRxOffset,

    TUint8& aTxHeaderSpace,

    TUint8& aTxTrailerSpace ) const

    {

    aRxOffset = iPimpl->WHASettings().iRxoffset;

    aTxHeaderSpace = iPimpl->WHASettings().iTxFrameHeaderSpace;

    aTxTrailerSpace = iPimpl->WHASettings().iTxFrameTrailerSpace;

    }

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

// 

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

//

TBool Umac::TxPermitted( TWhaTxQueueState& aTxQueueState ) const

    {

    return ( iPimpl->ProtocolStackTxDataAllowed() && 

             iPimpl->GetWhaTxStatus( aTxQueueState ) );

    }

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

// 

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

//

TBool Umac::UserDataTxEnabled() const

    {

    return ( iPimpl->ProtocolStackTxDataAllowed() );

    }

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

// 

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

//

void Umac::WriteMgmtFrame(TDataBuffer& aDataBuffer)

    {

    iPimpl->CurrentState().TxMgmtData( *iPimpl, aDataBuffer );

    }

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

// 

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

//

void Umac::HandleOid(

    const TOIDHeader* aOid,             

    TAny* aOutputBuffer,

    TUint aOutputBufferSize )

    {

    iManagementRequestPending = ETrue;

    iOidOutputData.iBufferSupplied = aOutputBuffer;

    iOidOutputData.iLengthOfBufferSupplied = aOutputBufferSize;

    iOidOutputData.iOidId = aOid->oid_id;

    if (// WHA layer in use 

        iPimpl->WsaCmdActive()

        || // OR

        // oid channel is disabled

        !(iPimpl->ChannelEnabled( WlanEventDispatcher::KOidChannel )) )

        {

        // ...defer access

        iPimpl->RegisterEvent( *aOid );

        return;

        }

    switch(aOid->oid_id)

        {

        case E802_11_CONFIGURE:

            HandleConfigure( aOid );

            break;

        case E802_11_CONNECT:

            HandleConnect( aOid );

            break;

        case E802_11_START_IBSS:

            HandleStartIBSS(aOid);

            break;

        case E802_11_SCAN:

            HandleScan( aOid );

            break;

        case E802_11_STOP_SCAN:

            HandleStopScan();

            break;               

        case E802_11_DISCONNECT:

            HandleDisconnect();

            break;

        case E802_11_SET_POWER_MODE:

            HandleSetPowerMode(aOid);

            break;

        case E802_11_SET_RCPI_TRIGGER_LEVEL:

            HandleSetRcpiTriggerLevel(aOid);

            break;

        case E802_11_SET_TX_POWER_LEVEL:

            HandleSetTxPowerLevel(aOid);

            break;

        case E802_11_GET_LAST_RCPI:

            HandleGetLastRcpi();

            break;

        case E802_11_DISABLE_USER_DATA:

            HandleDisableUserData();

            break;

        case E802_11_ENABLE_USER_DATA:

            HandleEnableUserData();

            break;

        case E802_11_ADD_CIPHER_KEY:

            HandleAddCipherKey(aOid);

            break;            

        case E802_11_ADD_MULTICAST_ADDR:

            HandleAddMulticastAddr(aOid);

            break;            

        case E802_11_REMOVE_MULTICAST_ADDR:

            HandleRemoveMulticastAddr(aOid);

            break;            

        case E802_11_CONFIGURE_BSS_LOST:

            HandleConfigureBssLost(aOid);

            break;            

        case E802_11_SET_TX_RATE_ADAPT_PARAMS:

            HandleSetTxRateAdaptParams(aOid);

            break;            

        case E802_11_CONFIGURE_TX_RATE_POLICIES:

            HandleConfigureTxRatePolicies(aOid);

            break;            

        case E802_11_SET_POWER_MODE_MGMT_PARAMS:

            HandleSetPowerModeMgmtParams(aOid);

            break;            

        case E802_11_CONFIGURE_PWR_MODE_MGMT_TRAFFIC_OVERRIDE:

            HandleConfigurePwrModeMgmtTrafficOverride(aOid);

            break;            

        case E802_11_GET_FRAME_STATISTICS:

            HandleGetFrameStatistics();

            break;            

        case E802_11_CONFIGURE_UAPSD:

            HandleConfigureUapsd(aOid);

            break;            

        case E802_11_CONFIGURE_TX_QUEUE:

            HandleConfigureTxQueue(aOid);

            break;            

        case E802_11_GET_MAC_ADDRESS:

            HandleGetMacAddress();

            break;

        case E802_11_CONFIGURE_ARP_IP_ADDRESS_FILTERING:

            HandleConfigureArpIpAddressFiltering(aOid);

            break;

        case E802_11_CONFIGURE_HT_BLOCK_ACK:

            HandleConfigureHtBlockAck(aOid);

            break;

        case E802_11_CONFIGURE_PROPRIETARY_SNAP_HDR:

            HandleConfigureProprietarySnapHdr(aOid);

            break;

        default:

            OsTracePrint( KErrorLevel, 

                (TUint8*)("UMAC: OID: 0x%08x"), aOid->oid_id );    

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

            break;

        }

    }

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

// 

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

//

TBool Umac::HandleConnect(const TAny *aInputBuffer)

    {

    OsTracePrint( KWlmCmd, (TUint8*)("Umac::HandleConnect: WLM-E802_11_CONNECT") ); 

    const TConnectMsg* msg 

        = static_cast<const TConnectMsg*>(aInputBuffer);

#ifndef NDEBUG 

    OsTracePrint( KWlmCmdDetails, (TUint8*)

        ("Umac::HandleConnect: SSID:") ); 

    TUint8 ssidTraceBuf[KMaxSSIDLength + 1]; // + 1 for NULL termination

    os_memset( ssidTraceBuf, 0, sizeof( ssidTraceBuf ) );

    os_memcpy( ssidTraceBuf, msg->SSID.ssid, msg->SSID.ssidLength );

    OsTracePrint( KWlmCmdDetails, ssidTraceBuf ); 

    OsTracePrint( KWlmCmdDetails, (TUint8*)

        ("Umac::HandleConnect: BSSID:"), 

        msg->BSSID ); 

    OsTracePrint( KWlmCmdDetails, (TUint8*)

        ("Umac::HandleConnect: auth algorithm nbr: %d"), 

        msg->authAlgorithmNbr ); 

    OsTracePrint( KWlmCmdDetails, (TUint8*)

        ("Umac::HandleConnect: encryptionStatus: %d"), 

        msg->encryptionStatus ); 

    OsTracePrint( KWlmCmdDetails, (TUint8*)

        ("Umac::HandleConnect: pairwiseCipher: %d"), 

        msg->pairwiseCipher ); 

    OsTracePrint( KWlmCmdDetails, (TUint8*)

        ("Umac::HandleConnect: isInfra: %d"), 

        msg->isInfra ); 

    OsTracePrint( KWlmCmdDetails, (TUint8*)

        ("Umac::HandleConnect: scanResponseFrameBody (pointer): 0x%08x"), 

        reinterpret_cast<TUint32>(msg->scanResponseFrameBody) ); 

    OsTracePrint( KWlmCmdDetails, (TUint8*)

        ("Umac::HandleConnect: scanResponseFrameBodyLength: %d"), 

        msg->scanResponseFrameBodyLength ); 

    OsTracePrint( KWlmCmdDetails, (TUint8*)

        ("Umac::HandleConnect: ieData (pointer): 0x%08x"), 

        reinterpret_cast<TUint32>(msg->ieData) ); 

    OsTracePrint( KWlmCmdDetails, (TUint8*)

        ("Umac::HandleConnect: ieDataLength: %d"), 

        msg->ieDataLength ); 

    if ( msg->ieData )

        {

        OsTracePrint( KWlmCmdDetails, (TUint8*)

            ("Umac::HandleConnect: ieData data:"), 

            msg->ieData, msg->ieData + msg->ieDataLength  ); 

        }        

    OsTracePrint( KWlmCmdDetails, (TUint8*)

        ("Umac::HandleConnect: invalidatePairwiseKey (bool): %d"), 

        msg->invalidatePairwiseKey ); 

    OsTracePrint( KWlmCmdDetails, (TUint8*)

        ("Umac::HandleConnect: invalidateGroupKey (bool): %d"), 

        msg->invalidateGroupKey );