--- /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 <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));
+ }
+