/*

* Copyright (c) 2006-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:   WlanOsa implementation

*

*/

/*

* %version: 9 %

*/

#include "osa_includeme.h"

#include <kern_priv.h>

#include "osa.h"

#include "osadfc.h"

#include "osatimer.h"

#ifdef __WLAN_ENABLE_DMA

    #include "osamemorypool.h"

#else

    // allocator for general purpose memory

    extern void* GpAlloc( TInt aSize, TBool aZeroStamp );

    // free for general purpose memory

    extern void GpFree( void* aPtr );

#endif // __WLAN_ENABLE_DMA

struct WlanOsaImpl : public DBase, public WlanObject

    {

    /**

     * Ctor

     *

     * @since S60 v3.2

     */

    inline WlanOsaImpl();

    /**

     * Dtor

     *

     * @since S60 v3.2

     */

    virtual ~WlanOsaImpl();

    /**

     * Initializes the object instance.

     * Note! Needs to be executed successfully after object instance

     * construction to be able to use the instance.

     *

     * @param aUseCachedMemory ETrue if cached interconnect memory shall be used

     *                         EFalse otherwise

     * @param aAllocationUnit allocation unit size for interconnect memory in

     *        bytes

     * @return ETrue when successful

     *         EFalse otherwise

     */

    TBool Initialize( TBool aUseCachedMemory, TInt aAllocationUnit );

    /**

     * mutex

     * Not Own.

     */

    DMutex*         iMutex;

#ifdef __WLAN_ENABLE_DMA

    /**

     * memorypool

     */

    WlanMemoryPool*  iMemoryPool;

#endif // __WLAN_ENABLE_DMA

private:

    // Prohibit copy constructor.

    WlanOsaImpl( const WlanOsaImpl& );

    // Prohibit assigment operator.

    WlanOsaImpl& operator= ( const WlanOsaImpl& );

    };

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

//

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

//

WlanOsaImpl::WlanOsaImpl(): iMutex( NULL ), iMemoryPool( NULL )

    {

    Validate();

    }

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

//

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

//

WlanOsaImpl::~WlanOsaImpl()

    {

#ifdef __WLAN_ENABLE_DMA

    if ( iMemoryPool )

        {

        delete iMemoryPool;

        iMemoryPool = NULL;

        }

#endif // __WLAN_ENABLE_DMA

    }

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

//

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

//

TBool WlanOsaImpl::Initialize( TBool aUseCachedMemory, TInt aAllocationUnit )

    {

    TBool status( ETrue );

#ifdef __WLAN_ENABLE_DMA

    iMemoryPool = new WlanMemoryPool( aUseCachedMemory, aAllocationUnit );

    if ( iMemoryPool )

        {

        if ( !iMemoryPool->IsValid() )

            {

            TraceDump(ERROR_LEVEL,

                ("[WLAN] WlanOsaImpl::Initialize: ERROR: WLAN mem pool invalid"));

            status = EFalse;

            // memory pool will be freed in the destructor

            }

        }

    else

        {

        TraceDump(ERROR_LEVEL,

            ("[WLAN] WlanOsaImpl::Initialize: ERROR: WLAN mem pool alloc failed"));

        status = EFalse;

        }

#endif // __WLAN_ENABLE_DMA

    return status;

    }

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

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

//

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

//

WlanOsa::~WlanOsa()

    {

    TraceDump(INFO_LEVEL, ("[WLAN] WlanOsa dtor"));

    iDfcQueue = NULL;

    if ( IsValid() )

        {

        // we are valid -> proceed

        // close the mutex

        TraceDump(MUTEX_LEVEL, ("[WLAN] WlanOsa close mutex"));

        if ( Pimpl().iMutex )

            {

            Pimpl().iMutex->Close( NULL );

            }

        if ( iPimpl )

            {

            delete iPimpl;

            iPimpl = NULL;

            }

        }

    }

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

//

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

//

WlanOsa::WlanOsa() : iPimpl( NULL ), iDfcQueue( NULL )

    {

    TraceDump(INFO_LEVEL, ("[WLAN] WlanOsa ctor"));

    iPimpl = new WlanOsaImpl();

    if ( iPimpl )

        {

        if ( iPimpl->IsValid() )

            {

            // allocation success & object valid -> proceed

            Validate();

            const TUint mutex_order( KMutexOrdGeneral7 );

            TraceDump(MUTEX_LEVEL,

                (("[WLAN] WlanOsa mutex create: order: %d"), mutex_order));

            const TInt ret( Kern::MutexCreate(

                Pimpl().iMutex, KNullDesC, mutex_order) );

            if ( ret != KErrNone )

                {

                delete iPimpl;

                // and invalidate

                InValidate();

                }

            }

        else

            {

            // osa impl is invalid. Deallocate it

            delete iPimpl;

            // we are invalid, too

            InValidate();

            }

        }

    else

        {

        // allocation failed invalidate object

        InValidate();

        }

    }

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

//

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

//

TBool WlanOsa::Initialize( 

    TBool aUseCachedMemory, 

    TInt aAllocationUnit,

    void* aDfcQueue )

    {

    TraceDump(INFO_LEVEL, ("[WLAN] WlanOsa::Initialize()"));

    TBool status( ETrue );

    iDfcQueue = aDfcQueue;

    if ( iPimpl )

        {

        status = Pimpl().Initialize( aUseCachedMemory, aAllocationUnit );

        }

    else

        {

        status = EFalse;

        }

    TraceDump(INFO_LEVEL, (("[WLAN] WlanOsa::Initialize(): status (bool): %d"),

        status));

    return status;

    }

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

// From class MWlanOsa.

//

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

//

void* WlanOsa::Alloc( TOsaMemoryType aOsaMemoryType, TInt aSize, TUint aFlags )

    {

#ifdef __WLAN_ENABLE_DMA

    return Pimpl().iMemoryPool->Alloc(

        aOsaMemoryType,

        aSize,

        (aFlags & KAllocZeroStampMask) );

#else

    return GpAlloc( aSize, (aFlags & KAllocZeroStampMask) );

#endif // __WLAN_ENABLE_DMA

    }

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

// From class MWlanOsa.

//

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

//

void WlanOsa::Free( void* aPtr )

    {

#ifdef __WLAN_ENABLE_DMA

    Pimpl().iMemoryPool->Free( aPtr );

#else

    GpFree( aPtr );

#endif // __WLAN_ENABLE_DMA

    }

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

// From class MWlanOsa.

//

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

//

MWlanDfc* WlanOsa::DfcCreate()

    {

    TraceDump(INFO_LEVEL, ("[WLAN] WlanOsa::DfcCreate()"));

    WlanDfc* dfc( new WlanDfc( *this, iDfcQueue ) );

    if ( dfc )

        {

        if ( !(dfc->IsValid()) )

            {

            // construct failure -> destroy

            delete dfc;

            dfc = NULL;

            }

        }

    TraceDump(INFO_LEVEL, (("dfc addr: 0x%08x"), dfc));

    return dfc;

    }

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

// From class MWlanOsa.

//

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

//

void WlanOsa::DfcDestroy( MWlanDfc* aWlanDfc )

    {

    TraceDump(INFO_LEVEL, ("[WLAN] WlanOsa::DfcDestroy()"));

    delete aWlanDfc;

    }

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

// From class MWlanOsa.

//

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

//

MWlanTimer* WlanOsa::TimerCreate()

    {

    TraceDump(INFO_LEVEL, ("[WLAN] WlanOsa::TimerCreate()"));

    WlanTimer* timer( new WlanTimer( *this, iDfcQueue ) );

    if ( timer )

        {

        if ( !(timer->IsValid()) )

            {

            // construct failure -> destroy

            delete timer;

            timer = NULL;

            }

        }

    else

        {

        TraceDump(INFO_LEVEL, ("[WLAN] WlanOsa::TimerCreate() no memory"));

        }

    return timer;

    }

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

// From class MWlanOsa.

//

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

//

void WlanOsa::TimerDestroy( MWlanTimer* aWlanTimer )

    {

    TraceDump(INFO_LEVEL, ("[WLAN] WlanOsa::TimerDestroy()"));

    WlanTimer* timer = static_cast< WlanTimer* >( aWlanTimer );

    // dequeue just in case

    timer->Dequeue();

    // remove the final reference to the timer instance - this will

    // cause the object to destroy itself when it is ready to go

    // (the timer DFC been completed.)

    timer->RefDel();

    }

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

// From class MWlanOsa.

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

//

TInt MWlanOsa::MemCmp( const void* aLhs,

                 const void* aRhs,

                 TInt aNumOfBytes )

    {

    return memcompare(

        static_cast<const TUint8*>(aLhs), aNumOfBytes,

        static_cast<const TUint8*>(aRhs), aNumOfBytes );

    }

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

// From class MWlanOsa.

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

//

void* MWlanOsa::MemCpy( void* aDest,

                  const void* aSrc,

                  TUint aLengthinBytes )

    {

    return memcpy( aDest, aSrc, aLengthinBytes );

    }

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

// From class MWlanOsa.

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

//

void* MWlanOsa::WordCpy( TInt* aDest, const TInt* aSrc, TUint aLengthinBytes )

    {

    return wordmove( aDest, aSrc, aLengthinBytes );

    }

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

// From class MWlanOsa.

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

//

void* MWlanOsa::MemClr( void* aDest, TUint aLengthinBytes )

    {

    return memclr( aDest, aLengthinBytes );

    }

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

// From class MWlanOsa.

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

//

void* MWlanOsa::MemSet( void* aDest,

                  TInt aValue,

                  TUint aCount )

    {

    return memset( aDest, aValue, aCount );

    }

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

// From class MWlanOsa.

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

//

TInt64 MWlanOsa::Time()

    {

    return Kern::SystemTime();

    }

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

// From class MWlanOsa.

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

//

void MWlanOsa::BusyWait( TUint aWaitTimeInMicroSeconds )

    {

    const TInt KMicroSecsToNanoSecs( 1000 );

    Kern::NanoWait( aWaitTimeInMicroSeconds * KMicroSecsToNanoSecs );

    }

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

// From class MWlanOsaExt.

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

//

void WlanOsa::MutexAcquire()

    {

    TraceDump(MUTEX_LEVEL, ("[WLAN] WlanOsa::MutexAcquire() +"));

    TraceDump(MUTEX_LEVEL, (("[WLAN] current thread id: %d"),

        (Kern::CurrentThread()).iId));

    // acquire mutex

    Kern::MutexWait( *(Pimpl().iMutex) );

    TraceDump(MUTEX_LEVEL, ("[WLAN] WlanOsa::MutexAcquire() -"));

    TraceDump(MUTEX_LEVEL, (("[WLAN] current thread id: %d"),

        (Kern::CurrentThread()).iId));

    }

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

// From class MWlanOsaExt.

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

//

void WlanOsa::MutexRelease()

    {

    TraceDump(MUTEX_LEVEL, ("[WLAN] WlanOsa::MutexRelease() +"));

    TraceDump(MUTEX_LEVEL, (("[WLAN] current thread id: %d"),

        (Kern::CurrentThread()).iId));

    // release mutex

    Kern::MutexSignal( *(Pimpl().iMutex) );

    TraceDump(MUTEX_LEVEL, ("[WLAN] WlanOsa::MutexRelease() -"));

    TraceDump(MUTEX_LEVEL, (("[WLAN] current thread id: %d"),

        (Kern::CurrentThread()).iId));

    }