/*

* 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 DWlanLogicalChannel class.

*

*/

/*

*/

#include "WlLddWlanLddConfig.h"

#include "wlanlddcommon.h"

#include "WlanLogicalChannel.h"

#include "EthernetFrameMemMngr.h"

#include "EtherCardIoc.h"

#include "RWlanLogicalChannel.h"

#include "Umac.h"

#include "wllddoidmsgstorage.h"

#include "WlanLogicalDevice.h"

#include "osachunk.h"

#ifdef RD_WLAN_DDK

#include "osa.h"

#include "wlanpddiface.h"

#endif

extern TAny* os_alloc( const TUint32 );

extern void os_free( const TAny* );

// Tx memory for frames created by UMAC

const TUint32 KDmaTxMemSize = 4096; // equals to 1 MMU page on most systems

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

// 

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

//

#ifndef RD_WLAN_DDK

DWlanLogicalChannel::DWlanLogicalChannel( 

    DWlanLogicalDevice& aParent, 

    Umac& aUmac, 

    TDynamicDfcQue& aDfcQ,

    DMutex& aMutex, 

    DChunk*& aSharedMemoryChunk,

    WlanChunk*& aRxFrameMemoryPool )

#else    

DWlanLogicalChannel::DWlanLogicalChannel( 

    DWlanLogicalDevice& aParent, 

    Umac& aUmac, 

    TDynamicDfcQue& aDfcQ,

    WlanOsa*& aOsa, 

    DChunk*& aSharedMemoryChunk,

    WlanChunk*& aRxFrameMemoryPool )

#endif    

    : 

        iClient( NULL ), 

        iUnit( KUnitMax ), 

        iUmac( aUmac ),

        iDfcQ ( &aDfcQ ),

        iParent( aParent ),

        iWlanGeneralRequestStatus( NULL ), 

		iWlanRequestNotifyStatus( NULL ),

        iWlanReceiveFrameStatus( NULL ), 

        iWlanSendFrameStatus( NULL ),

        iIndicationBuffer( NULL ), 

		iIndicationListHead( NULL ), 

        iFreeIndicationListHead( NULL ), 

		iResumeTxStatus( NULL ), 

        iEthernetReceiveFrameStatus( NULL ), 

		iEthernetFrameMemMngr( NULL ),

        iTimerDfc( TimerDfcDoToggle, this, 0 ),

        iTimer( OnTimeOut, this ),

        iVoiceCallEntryTimer( OnVoiceCallEntryTimerTimeOut, this ),

        iVoiceCallEntryTimerDfc( VoiceCallEntryTimerDfcDoToggle, this, 0 ),

        iNullTimer( OnNullTimerTimeOut, this ),

        iNullTimerDfc( NullTimerDfcDoToggle, this, 0 ),

        iNoVoiceTimer( OnNoVoiceTimerTimeOut, this ),

        iNoVoiceTimerDfc( NoVoiceTimerDfcDoToggle, this, 0 ),

        iKeepAliveTimer( OnKeepAliveTimerTimeOut, this ),

        iKeepAliveTimerDfc( KeepAliveTimerDfcDoToggle, this, 0 ),

        iActiveToLightPsTimer( OnActiveToLightPsTimerTimeOut, this ),

        iActiveToLightPsTimerDfc( ActiveToLightPsTimerDfcDoToggle, this, 0 ),

        iLightPsToActiveTimer( OnLightPsToActiveTimerTimeOut, this ),

        iLightPsToActiveTimerDfc( LightPsToActiveTimerDfcDoToggle, this, 0 ),

        iLightPsToDeepPsTimer( OnLightPsToDeepPsTimerTimeOut, this ),

        iLightPsToDeepPsTimerDfc( LightPsToDeepPsTimerDfcDoToggle, this, 0 ),

        iDfc( DfcDoToggle, this, 0 ),

        iTxTriggerDfc( TxTriggerDfcDoToggle, this, 0 ),

        iFlags( 0 ), 

        iPowerHandler( *this, aDfcQ ), 

        iPoweringDown( EFalse ), 

        iDfcCtx( NULL ), 

#ifndef RD_WLAN_DDK       

        iMutex( aMutex  ),

#else        

        iOsa( aOsa  ),

#endif

        iSharedMemoryChunk( aSharedMemoryChunk ),

        iRxFrameMemoryPool( aRxFrameMemoryPool ),

        iTxActive( EFalse ),

        iAddTxFrameAllowed( ETrue )

    {

    TraceDump(INIT_LEVEL, (("WLANLDD: DWlanLogicalChannel Ctor: 0x%08x"), this));

	iTimerDfc.SetDfcQ( iDfcQ );

	iVoiceCallEntryTimerDfc.SetDfcQ( iDfcQ );

	iNullTimerDfc.SetDfcQ( iDfcQ );

	iNoVoiceTimerDfc.SetDfcQ( iDfcQ );

	iKeepAliveTimerDfc.SetDfcQ( iDfcQ );

	iActiveToLightPsTimerDfc.SetDfcQ( iDfcQ );

	iLightPsToActiveTimerDfc.SetDfcQ( iDfcQ );

	iLightPsToDeepPsTimerDfc.SetDfcQ( iDfcQ );

	iDfc.SetDfcQ( iDfcQ );

	iTxTriggerDfc.SetDfcQ( iDfcQ );

    // store client thread ID

    iClient = &Kern::CurrentThread();

    TraceDump(INIT_LEVEL, (("WLANLDD: current thread 0x%08x"), iClient));

    // open a refernce to client thread, so we don't get out of scope

    ((DObject*)iClient)->Open();

    }

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

// 

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

//

DWlanLogicalChannel::~DWlanLogicalChannel()

    {

    TraceDump(INIT_LEVEL, (("WLANLDD: DWlanLogicalChannel Dtor: 0x%08x"), this));

    if ( iUnit == KUnitWlan )

        {

        iTimerDfc.Cancel();

        iVoiceCallEntryTimerDfc.Cancel();

        iNullTimerDfc.Cancel();

        iNoVoiceTimerDfc.Cancel();

        iKeepAliveTimerDfc.Cancel();

        iActiveToLightPsTimerDfc.Cancel(); 

        iLightPsToActiveTimerDfc.Cancel(); 

        iLightPsToDeepPsTimerDfc.Cancel(); 

        iDfc.Cancel();

        // if there are any indication items currently pending, free them by

        // moving them to the free list

        PurgeIndicationList();

        // delete all indication items from the free list

        FreeIndicationList();

        // detach management side callback

        TraceDump(INIT_LEVEL, ("WLANLDD: detach managemement side callback from UMAC"));

        iUmac.Detach();

        if ( iFlags & KPowerHandlerRegistered )

            {

            // we have registered our power handler

            // if we stopping operations because of a power down request from power

            // manager, acknowledge back to power manager that we are now done

            if ( iPoweringDown )

                {

                TraceDump(INIT_LEVEL, 

                    (("WLANLDD: DWlanLogicalChannel::~DWlanLogicalChannel(): signalling powerDownDone")));

                iPowerHandler.OnPowerDownDone();        

                }

            // de-register our power handler from the power manager

            TraceDump(INIT_LEVEL, 

                (("WLANLDD: DWlanLogicalChannel::~DWlanLogicalChannel(): de-register our powerhandler")));

            iPowerHandler.Remove();

            // destroy UMAC internal Tx memory buffer

            iDmaTxMemory.Finit();            

            }

        }

    else if ( iUnit == KUnitEthernet )

        {

        iTxTriggerDfc.Cancel();

        // detach protocol stack side callback

        TraceDump(INIT_LEVEL, 

            ("WLANLDD: detach protocol stack side callback from UMAC"));

        iUmac.DetachProtocolStackSideUmacCb();

        }

    if ( iEthernetFrameMemMngr )

        {

        TraceDump(INIT_LEVEL, ("WLANLDD: deallocate ethernet frame memory pool"));

        TraceDump(MEMORY, (("WLANLDD: delete DEthernetFrameMemMngr: 0x%08x"), 

        reinterpret_cast<TUint32>(iEthernetFrameMemMngr)));        

        delete iEthernetFrameMemMngr;

        iEthernetFrameMemMngr = NULL;

        }

    iDfcQ = NULL; // destroyed elsewhere (by the owner)

    // close our refernce to client thread as the very last thing we do

    Kern::SafeClose( reinterpret_cast<DObject*&>(iClient), NULL);

    }

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

// 

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

//

DChunk*& DWlanLogicalChannel::SharedMemoryChunk()

    {

    return iSharedMemoryChunk;

    }

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

// 

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

//

void DWlanLogicalChannel::SetRxBufAlignmentPadding( 

    TInt aRxBufAlignmentPadding )

    {

    iParent.SetRxBufAlignmentPadding( aRxBufAlignmentPadding );

    }

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

// 

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

//

TInt DWlanLogicalChannel::RxBufAlignmentPadding() const

    {

    return iParent.RxBufAlignmentPadding();

    }

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

// 

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

//

TBool DWlanLogicalChannel::InitIndicationListEntries()

    {

    // Initialize indication list entries

    TBool ret( ETrue );     // true for success     

    for ( TUint32 i = 0 ; i < KMaxIndicationListEntries; ++i )

        {

        TIndicationListEntry* tmp = new TIndicationListEntry;

        if ( tmp )

            {

            TraceDump(MEMORY, (("WLANLDD: new TIndicationListEntry: 0x%08x"), 

            reinterpret_cast<TUint32>(tmp)));

            // The ReleaseIndicationListEntry 

            // function can also be used for initialization

            ReleaseIndicationListEntry( tmp );

            }

        else

            {

            // alloc failed no use to continue

            ret = EFalse;

            break;

            }

        }

    return ret;

    }

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

// If an error occurs in this method, we set iPdd to NULL to prevent 

// PDD object destruction in base class (DLogicalChannelBase) destructor.

// DLogicalChannelBase destructor gets called as this logical channel instance

// gets destoyed when this method returns with an error.

// The PDD object gets destructed elsewhere.

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

//

TInt DWlanLogicalChannel::DoCreate(

    TInt aUnit, 

    const TDesC8* /*aInfo*/, 

    const TVersion& /*aVer*/ )

    {

    TraceDump(INIT_LEVEL, ("WLANLDD: DWlanLogicalChannel::DoCreate"));

    TraceDump(INIT_LEVEL, 

        (("WLANLDD: current thread 0x%08x"), &Kern::CurrentThread()));

    TraceDump(INIT_LEVEL, (("WLANLDD: aUnit %d"), aUnit));

    if ( !Kern::CurrentThreadHasCapability( 

             ECapabilityCommDD,

             __PLATSEC_DIAGNOSTIC_STRING( "Checked by wlan.ldd")))

        {

        iPdd = NULL;

        return KErrPermissionDenied;

        }

    // enable reception of requests from user mode

    SetDfcQ(iDfcQ);

    iMsgQ.Receive();

    // length of the allocation unit to be used for OSA interconnect 

    // (DMA capable) memory and frame Rx/Tx buffers. 

    // If WLAN DDK is used and the WLAN PDD capabilities query below 

    // returns a non-NULL response and the PDD indicates support for

    // cached memory, we use the length of the processor's cache line 

    // - returned in that response - as the allocation unit length.

    // Otherwise we use this default value

    TInt allocationUnit ( 32 );

    iUnit = aUnit;  // store the unit

    // PDD has been loaded and created by the framework at this point

    if ( iUnit == KUnitWlan )

        {

        if ( !InitIndicationListEntries() )

            {

            iPdd = NULL;

            return KErrNoMemory;

            }

        // attach management side callback

        TraceDump(INIT_LEVEL, ("WLANLDD: attach managemement side callback to UMAC"));

        iUmac.Attach( *this );

#ifndef RD_WLAN_DDK

        WHA::Wha* wha( reinterpret_cast<WHA::Wha*>(iPdd) );

        // attach the WHA object to UMAC

        TraceDump(INIT_LEVEL, ("WLANLDD: attach WHA object to UMAC"));

        iUmac.AttachWsa( wha );

#else

        MWlanPddIface* pdd( reinterpret_cast<MWlanPddIface*>(iPdd) );

        TraceDump(INIT_LEVEL, 

            (("WLANLDD: DWlanLogicalChannel::DoCreate: wlanpdd addr: 0x%08x"), 

            pdd));

        // determine PDD capabilities

        MWlanPddIface::SCapabilities* pddCapabilities ( NULL );

        pdd->GetCapabilities( pddCapabilities );

        TraceDump(INIT_LEVEL, 

            (("WLANLDD: DWlanLogicalChannel::DoCreate: pddCapabilities ptr: 0x%08x"), 

            reinterpret_cast<TUint32>(pddCapabilities)));

        if ( pddCapabilities )

            {

            TraceDump(INIT_LEVEL, 

                (("WLANLDD: DWlanLogicalChannel::DoCreate: wlanpdd iCapabilities: 0x%08x"), 

                pddCapabilities->iCapabilities));

            if ( pddCapabilities->iCapabilities & 

                 MWlanPddIface::SCapabilities::KCachedMemory )

                {

                TraceDump(INIT_LEVEL, 

                    ("WLANLDD: DWlanLogicalChannel::DoCreate: use cached memory"));

                iParent.UseCachedMemory( ETrue );

                TraceDump(INIT_LEVEL, 

                    (("WLANLDD: DWlanLogicalChannel::DoCreate: wlanpdd iCacheLineLength: %d"), 

                    pddCapabilities->iCacheLineLength));

                allocationUnit = pddCapabilities->iCacheLineLength; 

                }

            delete pddCapabilities;

            pddCapabilities = NULL;

            }

        // initialize OSA

        if ( !iOsa->Initialize( 

                iParent.UseCachedMemory(), 

                allocationUnit,

                iDfcQ ) )

            {

            // init failed. We cannot continue

            TraceDump(ERROR_LEVEL, 

                ("WLANLDD: DWlanLogicalChannel::DoCreate: osa init failed, abort"));

            iPdd = NULL;

            return KErrGeneral;

            }

        TraceDump(INIT_LEVEL, 

            ("WLANLDD: DWlanLogicalChannel::DoCreate: attach osa and osaext to wlanpdd"));

        TraceDump(INIT_LEVEL, 

            (("WLANLDD: DWlanLogicalChannel::DoCreate: osa and osaext addr: 0x%08x"), 

            reinterpret_cast<TUint32>(iOsa)));

        // pass interfaces to PDD

        const TBool ret( pdd->Attach( *iOsa, *iOsa ) );

        if ( ret )

            {

            TraceDump(INIT_LEVEL, 

                ("WLANLDD: DWlanLogicalChannel::DoCreate: extract WHA and attach it to UMAC"));

            // extract wha and attach it to UMAC

            iUmac.AttachWsa( &(pdd->Extract()) );

            }

        else

            {

            // attach failure abort

            TraceDump(WARNING_LEVEL, ("WLANLDD: PDD attach failure -> abort"));

            iPdd = NULL;

            return KErrNoMemory;

            }

#endif

#ifndef RD_WLAN_DDK

        // pass the mutex to WHA

        wha->Mutex( reinterpret_cast<WHA::TMutexHandle>(&iMutex) );            

#endif

        // register our power handler with the power manager

        TraceDump(INIT_LEVEL, 

            (("WLANLDD: DWlanLogicalChannel::DoCreate: register our powerhandler")));

        iPowerHandler.Add();

        iFlags |= KPowerHandlerRegistered; // note that we have registered

        // create UMAC internal Tx memory buffer

        if ( iDmaTxMemory.Init( KDmaTxMemSize, iParent.UseCachedMemory() ) 

             == KDmaTxMemSize )

            {

            // success; no further action needed

            }

        else

            {

            // failure

            iPdd = NULL;

            return KErrNoMemory;

            }

        }

    else if ( iUnit == KUnitEthernet )

        {

        // attach protocol stack side callbac

        iUmac.AttachProtocolStackSideUmacCb( *this );

        }

    else

        {

        // unknown unit

        TraceDump(ERROR_LEVEL, 

            (("WLANLDD: DWlanLogicalChannel::DoCreate: ERROR: unknown unit: %d"), 

            iUnit));

        iPdd = NULL;

        return KErrPermissionDenied;

        }

    // init ethernet frame memory pool manager

    iEthernetFrameMemMngr = DEthernetFrameMemMngr::Init( 

        aUnit, 

        *this, 

        iRxFrameMemoryPool,

        iParent.UseCachedMemory(),

        allocationUnit );

    if ( iEthernetFrameMemMngr )

        {

        // init success -> continue

        TraceDump(INIT_LEVEL, (("WLANLDD: ethernet memory pool allocated: 0x%08x"),

            iEthernetFrameMemMngr));

        }

    else

        {

        // init failure no use to continue

        TraceDump(WARNING_LEVEL, 

            ("WLANLDD: ethernet memory pool allocation failure"));

        iPdd = NULL;

        return KErrNoMemory;

        }

    return KErrNone;

    }

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

// 

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

//

void DWlanLogicalChannel::HandleMsg(TMessageBase* aMsg)

    {

    TraceDump(WLM_CMD, ("WLANLDD: DWlanLogicalChannel::HandleMsg"));

    // we are now executing in a DFC thread context

    // acquire mutex

#ifndef RD_WLAN_DDK

    Kern::MutexWait( iMutex );

#else

    iOsa->MutexAcquire();

#endif

    TraceDump(MUTEX, 

        (("WLANLDD: DWlanLogicalChannel::HandleMsg: mutex acquired")));

    TThreadMessage& m = *reinterpret_cast<TThreadMessage*>( aMsg );

    TraceDump(WLM_CMD_DETAILS, (("WLANLDD: current thread 0x%08x"), 

        &Kern::CurrentThread()));       

    TraceDump(WLM_CMD_DETAILS, (("WLANLDD: client thread 0x%08x"), m.Client()));    

    TraceDump(WLM_CMD_DETAILS, (("WLANLDD: channel creator thread 0x%08x"), 

        iClient));

    // Get message type

    TInt id = m.iValue;

    TraceDump(WLM_CMD_DETAILS, (("WLANLDD: message id: %d"), id));

    // Decode the message type and dispatch it to the relevent handler function...

    // A logical channel can be closed either explicitly by its user-side client,

    // or implicitly if the client thread dies. In the latter case, the channel

    // is closed in the context of the kernel supervisor thread. 

    if ( id == ECloseMsg )

        {

        TraceDump(WLM_CMD_DETAILS, ("WLANLDD: close message"));