/*

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

*

*/

/*

*/

#include "WlLddWlanLddConfig.h"

#include "WlanLogicalDevice.h"

#include "WlanLogicalChannel.h"

#include "wlanlddcommon.h"

#include "osachunk.h"

#include <kern_priv.h>

const TUint KWlanParseMask = KDeviceAllowUnit | KDeviceAllowPhysicalDevice;

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

// 

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

//

DECLARE_STANDARD_LDD()

    {

    TraceDump(INIT_LEVEL, ("WLANLDD: allocate logical device object"));    

    // alloc the device

#ifndef RD_WLAN_DDK

    return new DWlanLogicalDevice;

#else        

    DWlanLogicalDevice* logicalDevice( new DWlanLogicalDevice );

        {

        // something went wrong

        delete logicalDevice;

        logicalDevice = NULL;

        }

    return logicalDevice;

#endif

    }

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

// 

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

//

DWlanLogicalDevice::DWlanLogicalDevice()

    :

    iDfcQ( NULL ),

#ifndef RD_WLAN_DDK

    iMutex( NULL ),

#else

    iOsa( NULL ),    

#endif    

    iUseCachedMemory( EFalse ),

	iRxFrameMemoryPool( NULL ),

	iRxBufAlignmentPadding( 0 )

	{

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

	iParseMask = KWlanParseMask;

    iUnitsMask = KWlanUnitsAllowedMask;

    TraceDump(INIT_LEVEL, (("iUnitsMask: 0x%08x"), iUnitsMask));

    TraceDump(INIT_LEVEL, (("iParseMask: 0x%08x"), iParseMask));

	iVersion = TVersion(KWlanDriverMajorVersion,KWlanDriverMinorVersion,KWlanDriverBuildVersion);

	}

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

// 

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

//

DWlanLogicalDevice::~DWlanLogicalDevice()

	{

    TraceDump(INIT_LEVEL, ("WLANLDD: DWlanLogicalDevice dtor"));

    delete iRxFrameMemoryPool;

    iRxFrameMemoryPool = NULL;

#ifndef RD_WLAN_DDK

    if ( iMutex )

        {

        TraceDump(MUTEX, ("WLANLDD: DWlanLogicalDevice dtor: close the mutex"));

        iMutex->Close( NULL ); 

        iMutex = NULL;       

        }

#else

    if ( iOsa )

        {

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

            reinterpret_cast<TUint32>(iOsa)));

        delete iOsa;

        iOsa = NULL;

        }

#endif // RD_WLAN_DDK      

    if( iDfcQ )

        {

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

            reinterpret_cast<TUint32>(iDfcQ)));

        iDfcQ->Destroy();

        }

	}

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

// 

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

//

TInt DWlanLogicalDevice::Create( DLogicalChannelBase *&aChannel )

    {

    TraceDump(INIT_LEVEL, ("WLANLDD: DWlanLogicalDevice::Create"));

    TInt ret = KErrNoMemory;

    // UMAC exists we may proceed

    aChannel = 

#ifndef RD_WLAN_DDK

        new DWlanLogicalChannel( 

            *this,

            iUmac,

            *iDfcQ,

            *iMutex, 

            iSharedMemoryChunk, 

            iRxFrameMemoryPool );

#else                

        new DWlanLogicalChannel( 

            *this,

            iUmac,

            *iDfcQ,

            iOsa, 

            iSharedMemoryChunk, 

            iRxFrameMemoryPool );

#endif        

    if ( aChannel )

        {

        ret = KErrNone;

        }

    else

        {

        // allocation failed

        TraceDump(WARNING_LEVEL, 

            ("WLANLDD: DWlanLogicalDevice::Create: logical channel allocation failure"));

        }

    return ret;

    }

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

// 

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

//

TInt DWlanLogicalDevice::Install()

	{

    TraceDump(INIT_LEVEL, ("WLANLDD: DWlanLogicalDevice::Install"));

    _LIT(KWlanDdThreadName, "WlanDdThread");

    const TInt KWlanDdThreadPriority = 27;

    TInt ret( 0 );

    // create our own DFC queue (and thread)

    ret = Kern::DynamicDfcQCreate( 

        iDfcQ, 

        KWlanDdThreadPriority, 

        KWlanDdThreadName );

    if ( ret != KErrNone )

        {

        TraceDump(ERROR_LEVEL, 

            ("WLANLDD: DWlanLogicalDevice::Install: DFC queue creation failed -> aborting"));

        return ret;

        }

    else

        {

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

            reinterpret_cast<TUint32>(iDfcQ)));        

        }

#ifndef RD_WLAN_DDK

    ret = Kern::MutexCreate( iMutex, KNullDesC, KMutexOrdGeneral7);

    TraceDump(MUTEX, 

        (("WLANLDD: DWlanLogicalDevice::Install: mutex create; status: %d"), 

        ret));

    if ( ret )

        {

        // mutex creation failed

        TraceDump(ERROR_LEVEL, 

            ("WLANLDD: DWlanLogicalDevice::Install: mutex creation failed -> aborting"));

        ret = KErrGeneral;                                

        }

#else

    // create OSA

    iOsa = new WlanOsa();

    if ( iOsa )

        {

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

            reinterpret_cast<TUint32>(iOsa)));

        if ( !( iOsa->IsValid() ) )

            {

            // OSA is not valid. That's fatal

            // OSA object instance will be deallocated in the destructor

            TraceDump(ERROR_LEVEL, 

                ("WLANLDD: DWlanLogicalDevice::Install: osa not valid, abort"));

            ret = KErrGeneral;

            }                

        }

    else

        {

        // allocation failed

        TraceDump(ERROR_LEVEL, 

            ("WLANLDD: DWlanLogicalDevice::Install: osa alloc failed, abort"));

        ret = KErrNoMemory;

        }

#endif

    if ( !ret )

        {        

        // init the UMac

        if ( iUmac.Init() )

            {

            const TPtrC name= LDD_NAME;

            ret = SetName(&name);

            }

        else

            {

            TraceDump(WARNING_LEVEL, 

                ("WLANLDD: DWlanLogicalDevice::Install: UMAC init failed -> aborting "));

            ret = KErrGeneral;

            }

        }

    return ret;

	}

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

// 

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

//

void DWlanLogicalDevice::GetCaps(TDes8& aDes) const

	{

    TraceDump(INIT_LEVEL, ("WLANLDD: DWlanLogicalDevice::GetCaps"));

    DWlanLogicalDevice::TCaps caps;

	caps.iVersion=iVersion;

    // write back to user mode

    Kern::InfoCopy( aDes, reinterpret_cast<TUint8*>(&caps), sizeof(caps) );

	}

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

// 

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

//

TBool DWlanLogicalDevice::UseCachedMemory() const

    {

    return iUseCachedMemory;

    }

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

// 

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

//

void DWlanLogicalDevice::UseCachedMemory( TBool aValue )

    {

    iUseCachedMemory = aValue;

    }

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

// 

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

//

void DWlanLogicalDevice::SetRxBufAlignmentPadding( 

    TInt aRxBufAlignmentPadding )

    {

    iRxBufAlignmentPadding = aRxBufAlignmentPadding;

    }

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

// 

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

//

TInt DWlanLogicalDevice::RxBufAlignmentPadding() const

    {

    return iRxBufAlignmentPadding;

    }