diff -r 000000000000 -r c40eb8fe8501 wlan_bearer/wlanldd/wlan_symbian/osa_symbian/src/osa.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wlan_bearer/wlanldd/wlan_symbian/osa_symbian/src/osa.cpp Tue Feb 02 02:03:13 2010 +0200 @@ -0,0 +1,489 @@ +/* +* 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 + +#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(aLhs), aNumOfBytes, + static_cast(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)); + } +