FCL/sf/os/wlan: comparison wlan_bearer/wlanldd/wlan_symbian/wlanldd

equal deleted inserted replaced

-:629e60dfa279
+:c6a1762761b8
 * Description:   Implementation of the DWlanLogicalChannel class.
 *
 */
 /*
-* %version: 59 %
+* %version: 60 %
 */
 #include "WlLddWlanLddConfig.h"
 #include "wlanlddcommon.h"
 #include "WlanLogicalChannel.h"
 // Tx memory for frames created by UMAC
 const TUint32 KDmaTxMemSize = 4096; // equals to 1 MMU page on most systems
 // ---------------------------------------------------------------------------
-//
+// Note! This method is executed in the context of the user mode client
+// thread, but in supervisor mode
 // ---------------------------------------------------------------------------
 //
 #ifndef RD_WLAN_DDK
 DWlanLogicalChannel::DWlanLogicalChannel(
 DWlanLogicalDevice& aParent,
 return ret;
 }
 // ---------------------------------------------------------------------------
+// Note! This method is executed in the context of the user mode client
+// thread, but in supervisor mode
+//
 // 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.
 (("WLANLDD: DWlanLogicalChannel::HandleMsg: mutex released")));
 }
 // ---------------------------------------------------------------------------
-//
+// Note! This method is executed in the context of the user mode client
-// ---------------------------------------------------------------------------
+// thread, but in supervisor mode
-//
+// ---------------------------------------------------------------------------
-TAny* DWlanLogicalChannel::DoControlFast( TInt aFunction, TAny* param )
+//
+TAny* DWlanLogicalChannel::DoControlFast( TInt aFunction, TAny* aParam )
 {
 TAny* ret( NULL );
 TBool triggerTx ( EFalse );
 TraceDump(WLM_CMD_DETAILS,
 (("WLANLDD: DWlanLogicalChannel::DoControlFast: current thread 0x%08x"),
 &Kern::CurrentThread()));
 TraceDump(WLM_CMD_DETAILS, (("WLANLDD: channel creator thread: 0x%08x"),
 iClient));
 TraceDump(WLM_CMD_DETAILS, (("WLANLDD: function: 0x%x"), aFunction));
-// Note! We are executing in the context of the client's thread, but
-// in supervisor mode
 // acquire mutex
 // Enter critical section before requesting the mutex as
 // we are executing in the context of a user mode thread
 NKern::ThreadEnterCS();
 NKern::ThreadLeaveCS();
 TraceDump(MUTEX,
 (("WLANLDD: DWlanLogicalChannel::DoControlFast: mutex acquired")));
-switch ( aFunction )
+if ( iUnit == KUnitWlan )
 {
-case RPcmNetCardIf::EControlFastAllocTxBuffer:
+ret = OnMgmtSideControlFast( aFunction, aParam );
-ret = iEthernetFrameMemMngr->AllocTxBuffer(
+}
-reinterpret_cast<TUint>(param) );
+else if ( iUnit == KUnitEthernet )
+{
-if ( !ret && iAddTxFrameAllowed )
+ret = OnEthernetSideControlFast( aFunction, aParam, triggerTx );
-{
+}
-iAddTxFrameAllowed = EFalse;
+else
+{
-TraceDump( NWSA_TX,
+// unknown unit
-("WLANLDD: DWlanLogicalChannel::DoControlFast: stop flow from protocol stack") );
+#ifndef NDEBUG
-}
+TraceDump(ERROR_LEVEL,
-break;
+("WLANLDD: DWlanLogicalChannel::DoControlFast: unknown unit"));
+TraceDump(ERROR_LEVEL, (("WLANLDD: aFunction: %d"), aFunction));
-case RPcmNetCardIf::EControlFastAddTxFrame:
+TraceDump(ERROR_LEVEL, (("WLANLDD: unit: %d"), iUnit));
-{
+os_assert( (TUint8*)("WLANLDD: panic"), (TUint8*)(WLAN_FILE), __LINE__ );
-#ifndef NDEBUG
-if ( !iAddTxFrameAllowed )
-{
-TraceDump(ERROR_LEVEL,
-("WLANLDD: DWlanLogicalChannel::DoControlFast: WARNING: AddTxFrame req. when flow ctrl is on"));
-}
 #endif
-if ( iEthernetFrameMemMngr->AllTxQueuesEmpty() )
-{
-triggerTx = ETrue;
-}
-TDataBuffer* discardFrame ( NULL );
-ret = reinterpret_cast<TAny*>(iEthernetFrameMemMngr->AddTxFrame(
-reinterpret_cast<TDataBuffer*>(param),
-discardFrame,
-iUmac.UserDataTxEnabled() ));
-if ( discardFrame )
-{
-TraceDump( NWSA_TX_DETAILS,
-(("WLANLDD: DWlanLogicalChannel::DoControlFast: have to drop tx frame of UP: %d"),
-reinterpret_cast<TDataBuffer*>(param)->UserPriority()) );
-iEthernetFrameMemMngr->FreeTxPacket( discardFrame );
-}
-if ( !ret )
-{
-iAddTxFrameAllowed = EFalse;
-TraceDump( NWSA_TX,
-("WLANLDD: DWlanLogicalChannel::DoControlFast: stop flow from protocol stack") );
-}
-break;
-}
-default:
-#ifndef NDEBUG
-TraceDump(ERROR_LEVEL, (("WLANLDD: unknown request: %d"),
-aFunction));
-os_assert(
-(TUint8*)("WLANLDD: panic"),
-(TUint8*)(WLAN_FILE),
-__LINE__ );
-#endif
-break;
 }
 // release mutex
 // Enter critical section before releasing the mutex as
 // we are executing in the context of a user mode thread
 // DFC by a higher priority (kernel side) thread, and the latter will
 // also need to acquire the same mutex before it can proceed. So, as
 // the lower priority thread will get paused and the higher priority
 // thread will get scheduled (to execute the DFC), we don't want the
 // higher priority thread to need to wait for the mutex. So we
-// released the mutex first in this code block and after that enque
+// released the mutex first in this code block and after that enqueue
 // the DFC request.
 if ( !( iFlags & KTxTriggerArmed ) )
 {
 iFlags |= KTxTriggerArmed;
 iTxTriggerDfc.Enque();
 return ret;
 }
 // ---------------------------------------------------------------------------
+// Note! This method is executed in the context of the user mode client
+// thread, but in supervisor mode
+// ---------------------------------------------------------------------------
+//
+TAny* DWlanLogicalChannel::OnMgmtSideControlFast(
+TInt aFunction,
+TAny* aParam )
+{
+TAny* ret( NULL );
+switch ( aFunction )
+{
+// ==========================================================
+// Get Rx frame
+// ==========================================================
+case RWlanLogicalChannel::EWlanControlFastGetRxFrame:
+if ( iEthernetFrameMemMngr )
+{
+ret = iEthernetFrameMemMngr->GetRxFrame(
+reinterpret_cast<TDataBuffer*>(aParam) );
+}
+break;
+// ==========================================================
+// Unknown request
+// ==========================================================
+default:
+#ifndef NDEBUG
+TraceDump(ERROR_LEVEL, (("WLANLDD: unknown request: %d"),
+aFunction));
+os_assert(
+(TUint8*)("WLANLDD: panic"),
+(TUint8*)(WLAN_FILE),
+__LINE__ );
+#endif
+break;
+}
+return ret;
+}
+// ---------------------------------------------------------------------------
+// Note! This method is executed in the context of the user mode client
+// thread, but in supervisor mode
+// ---------------------------------------------------------------------------
+//
+TAny* DWlanLogicalChannel::OnEthernetSideControlFast(
+TInt aFunction,
+TAny* aParam,
+TBool& aTriggerTx )
+{
+TAny* ret( NULL );
+aTriggerTx = EFalse;
+switch ( aFunction )
+{
+// ==========================================================
+// Alloc Tx buffer
+// ==========================================================
+case RPcmNetCardIf::EControlFastAllocTxBuffer:
+if ( iEthernetFrameMemMngr )
+{
+ret = iEthernetFrameMemMngr->AllocTxBuffer(
+reinterpret_cast<TUint>(aParam) );
+}
+if ( !ret && iAddTxFrameAllowed )
+{
+iAddTxFrameAllowed = EFalse;
+TraceDump( NWSA_TX,
+("WLANLDD: DWlanLogicalChannel::OnEthernetSideControlFast: "
+"stop flow from protocol stack") );
+}
+break;
+// ==========================================================
+// Add Tx frame
+// ==========================================================
+case RPcmNetCardIf::EControlFastAddTxFrame:
+{
+#ifndef NDEBUG
+if ( !iAddTxFrameAllowed )
+{
+TraceDump(ERROR_LEVEL,
+("WLANLDD: DWlanLogicalChannel::OnEthernetSideControlFast: "
+"WARNING: AddTxFrame req. when flow ctrl is on"));
+}
+#endif
+if ( iEthernetFrameMemMngr && aParam )
+{
+if ( iEthernetFrameMemMngr->AllTxQueuesEmpty() )
+{
+aTriggerTx = ETrue;
+}
+TDataBuffer* discardFrame ( NULL );
+ret = reinterpret_cast<TAny*>(
+iEthernetFrameMemMngr->AddTxFrame(
+reinterpret_cast<TDataBuffer*>(aParam),
+discardFrame,
+iUmac.UserDataTxEnabled() ));
+if ( discardFrame )
+{
+TraceDump( NWSA_TX_DETAILS,
+(("WLANLDD: DWlanLogicalChannel::OnEthernetSideControlFast: "
+"have to drop tx frame of UP: %d"),
+reinterpret_cast<TDataBuffer*>(
+aParam)->UserPriority()) );
+iEthernetFrameMemMngr->FreeTxPacket( discardFrame );
+aTriggerTx = EFalse;
+}
+}
+if ( !ret )
+{
+iAddTxFrameAllowed = EFalse;
+TraceDump( NWSA_TX,
+("WLANLDD: DWlanLogicalChannel::OnEthernetSideControlFast: "
+"stop flow from protocol stack") );
+}
+break;
+}
+// ==========================================================
+// Get Rx frame
+// ==========================================================
+case RPcmNetCardIf::EControlFastGetRxFrame:
+{
+if ( iEthernetFrameMemMngr )
+{
+ret = iEthernetFrameMemMngr->GetRxFrame(
+reinterpret_cast<TDataBuffer*>(aParam) );
+}
+}
+break;
+// ==========================================================
+// Unknown request
+// ==========================================================
+default:
+#ifndef NDEBUG
+TraceDump(ERROR_LEVEL, (("WLANLDD: unknown request: %d"),
+aFunction));
+os_assert(
+(TUint8*)("WLANLDD: panic"),
+(TUint8*)(WLAN_FILE),
+__LINE__ );
+#endif
+break;
+} // switch
+return ret;
+}
+// ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void DWlanLogicalChannel::DoCancel( TInt aMask )
 {
 if ( iUnit == KUnitWlan )
 {
-if ( aMask & ( 1 << EWlanRequestNotify ) )
+if ( aMask & ( 1 << RWlanLogicalChannel::EWlanRequestNotify ) )
 {
 TraceDump(INFO_LEVEL,
 ("WLANLDD: DWlanLogicalChannel::DoCancel: mgmt side notify cancel"));
 CancelIndicationRequest();
 Kern::RequestComplete(
 iClient, iWlanRequestNotifyStatus, KErrServerTerminated );
 iWlanRequestNotifyStatus = NULL;
 }
-else if ( aMask & ( 1 << EWlanRequestFrame ) )
+else if ( aMask & ( 1 << RWlanLogicalChannel::EWlanRequestFrame ) )
 {
 TraceDump(INFO_LEVEL,
 ("WLANLDD: DWlanLogicalChannel::DoCancel: mgmt side frame read cancel"));
 Kern::RequestComplete(
 iWlanReceiveFrameStatus = NULL;
 }
 else
 {
 TraceDump(ERROR_LEVEL,
-(("WLANLDD: DWlanLogicalChannel::DoCancel: mgmt side unhandled mask panic: 0x%08x"),
+(("WLANLDD: DWlanLogicalChannel::DoCancel: mgmt side "
+"unhandled mask panic: 0x%08x"),
 aMask));
 os_assert( (TUint8*)("WLANLDD: panic"), (TUint8*)(WLAN_FILE), __LINE__ );
 }
 }
 else if ( iUnit == KUnitEthernet )
 iEthernetReceiveFrameStatus = NULL;
 }
 else
 {
 TraceDump(ERROR_LEVEL,
-(("WLANLDD: DWlanLogicalChannel::DoCancel: user side unhandled mask panic: 0x%08x"),
+(("WLANLDD: DWlanLogicalChannel::DoCancel: user side "
+"unhandled mask panic: 0x%08x"),
 aMask));
 os_assert( (TUint8*)("WLANLDD: panic"), (TUint8*)(WLAN_FILE), __LINE__ );
 }
 }
 else
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 TBool DWlanLogicalChannel::ProtocolStackDataReceiveComplete(
-const TDataBuffer*& aBufferStart,
+TDataBuffer*& aBufferStart,
 TUint32 aNumOfBuffers )
 {
-if ( iEthernetFrameMemMngr->OnEthernetFrameRxComplete( aBufferStart,
+if ( iEthernetFrameMemMngr &&
-aNumOfBuffers ) )
+iEthernetFrameMemMngr->OnEthernetFrameRxComplete(
+aBufferStart,
+aNumOfBuffers ) )
 {
 Kern::RequestComplete( iClient, iEthernetReceiveFrameStatus, KErrNone );
 iEthernetReceiveFrameStatus = NULL;
 }
 TraceDump(UMAC_PROTO_CALLBACK,
 ("WLANLDD: DWlanLogicalChannel::OnTxProtocolStackDataComplete"));
 TraceDump(UMAC_PROTO_CALLBACK,
 (("WLANLDD: aCompletionCode: %d"), aCompletionCode));
-iEthernetFrameMemMngr->FreeTxPacket( aMetaHeader );
+if ( iEthernetFrameMemMngr )
+{
+iEthernetFrameMemMngr->FreeTxPacket( aMetaHeader );
+}
 TxProtocolStackData();
 if ( !iAddTxFrameAllowed )
 {
 if ( iResumeTxStatus &&
+iEthernetFrameMemMngr &&
 iEthernetFrameMemMngr->ResumeClientTx(
 iUmac.UserDataTxEnabled() ) )
 {
 // resume Tx flow from protocol stack
 //
 // ---------------------------------------------------------------------------
 //
 void DWlanLogicalChannel::TxManagementData()
 {
-TDataBuffer* buffer = iEthernetFrameMemMngr->OnWriteEthernetFrame();
+TDataBuffer* buffer( NULL );
-if ( !buffer )
+if ( iEthernetFrameMemMngr )
 {
-TraceDump(ERROR_LEVEL,
+buffer = iEthernetFrameMemMngr->OnWriteEthernetFrame();
-("WLANLDD: DWlanLogicalChannel::TxManagementData: "
+}
-"panic, no buffer"));
+if ( buffer )
+{
+iUmac.WriteMgmtFrame( *buffer );
+}
+else
+{
+#ifndef NDEBUG
 os_assert( (TUint8*)("WLANLDD: panic"), (TUint8*)(WLAN_FILE), __LINE__ );
-}
+#endif
-else
+Kern::RequestComplete(
-{
+iClient, iWlanSendFrameStatus, KErrGeneral );
-iUmac.WriteMgmtFrame( *buffer );
 }
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void DWlanLogicalChannel::TxProtocolStackData()
 {
 #ifndef NDEBUG
 TUint packetsSubmitted ( 0 );
 #endif
 if ( !iTxActive )
 {
 //
 // ---------------------------------------------------------------------------
 //
 TBool DWlanLogicalChannel::OnReadEthernetFrameRequest()
 {
-const TBool ret = iEthernetFrameMemMngr->OnReadRequest();
+TBool ret( EFalse );
+if ( iEthernetFrameMemMngr )
+{
+ret = iEthernetFrameMemMngr->OnReadRequest();
+}
 return ret;
 }
 // ---------------------------------------------------------------------------
 //
 }
 }
 switch ( aReqNo )
 {
-case EWlanInitSystem:
+case RWlanLogicalChannel::EWlanInitSystem:
 // bootup the chip and the system
 iWlanGeneralRequestStatus = aStatus;
 InitSystem( a1, sizeof(TOpenParam) );
 break;
-case EWlanFinitSystem:
+case RWlanLogicalChannel::EWlanFinitSystem:
 // power down the chip and the system
 iWlanGeneralRequestStatus = aStatus;
 FinitSystem();
 break;
-case EWlanCommand:
+case RWlanLogicalChannel::EWlanCommand:
 // management command
 iWlanGeneralRequestStatus = aStatus;
 // read the USER mode parameters to internal storage
 ret = Kern::ThreadRawRead(
 // because it is not accessed by UMAC and the
 // actual user mode writing is done by OnOidCompleted method
 output_buffer.iData,
 output_buffer.iLen );
 break;
-case EWlanRequestNotify:
+case RWlanLogicalChannel::EWlanRequestNotify:
 // store the USER mode indication address;
 iIndicationBuffer = static_cast<TIndication*>(a1);
 iWlanRequestNotifyStatus = aStatus;
 IndicationRequest( static_cast<TIndication*>(a1) );
 break;
-case EWlanRequestFrame:
+case RWlanLogicalChannel::EWlanRequestFrame:
 if ( OnReadEthernetFrameRequest() )
 {
 // rx data to be completed exists
 // complete it directly
 Kern::RequestComplete(
 // no rx data for completion exists
 // store the pending request
 iWlanReceiveFrameStatus = aStatus;
 }
 break;
-case EWlanRequestSend:
+case RWlanLogicalChannel::EWlanRequestSend:
 iWlanSendFrameStatus = aStatus;
 TxManagementData();
 break;
 default:
 TInt aFunction,
 TAny* a1,
 TAny* /*a2*/ )
 {
 TInt ret( KErrNone );
-if ( aFunction == EWlanSvControlInitBuffers )
+if ( aFunction == RWlanLogicalChannel::EWlanSvControlInitBuffers )
 {
 // initiliaze buffers for wlan mgmt client data xfer
 if ( a1 )
 {
 TraceDump(INIT_LEVEL,
 TraceDump(ERROR_LEVEL,
 ("WLANLDD: DWlanLogicalChannel::OnMgmtSideControl(): init management client buffer pool panic"));
 os_assert( (TUint8*)("WLANLDD: panic"), (TUint8*)(WLAN_FILE), __LINE__ );
 }
 }
-else if ( aFunction == EWlanSvControlFreeBuffers )
+else if ( aFunction == RWlanLogicalChannel::EWlanSvControlFreeBuffers )
 {
 // free wlan mgmt client data xfer buffers
 OnReleaseEthernetFrameBuffers();
 }
 else
 TUint32 aSnapFrameTxOffset )
 {
 if ( iEthernetFrameMemMngr )
 {
 TraceDump(NWSA_TX_DETAILS,
-(("WLANLDD: DWlanLogicalChannel::SetMgmtSideTxOffsets: aEthernetFrameTxOffset: %d"),
+(("WLANLDD: DWlanLogicalChannel::SetMgmtSideTxOffsets: "
+"aEthernetFrameTxOffset: %d"),
 aEthernetFrameTxOffset ));
 TraceDump(NWSA_TX_DETAILS,
-(("WLANLDD: DWlanLogicalChannel::SetMgmtSideTxOffsets: aDot11FrameTxOffset: %d"),
+(("WLANLDD: DWlanLogicalChannel::SetMgmtSideTxOffsets: "
+"aDot11FrameTxOffset: %d"),
 aDot11FrameTxOffset ));
 TraceDump(NWSA_TX_DETAILS,
-(("WLANLDD: DWlanLogicalChannel::SetMgmtSideTxOffsets: aSnapFrameTxOffset: %d"),
+(("WLANLDD: DWlanLogicalChannel::SetMgmtSideTxOffsets: "
+"aSnapFrameTxOffset: %d"),
 aSnapFrameTxOffset ));
 iEthernetFrameMemMngr->SetTxOffsets(
 aEthernetFrameTxOffset,
 aDot11FrameTxOffset,
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void DWlanLogicalChannel::MgmtDataReceiveComplete(
-const TDataBuffer*& aBufferStart,
+TDataBuffer*& aBufferStart,
 TUint32 aNumOfBuffers )
 {
-if ( iEthernetFrameMemMngr->OnEthernetFrameRxComplete(
+if ( iEthernetFrameMemMngr &&
-aBufferStart,
+( iEthernetFrameMemMngr->OnEthernetFrameRxComplete(
-aNumOfBuffers ) )
+aBufferStart,
+aNumOfBuffers ) ) )
 {
 Kern::RequestComplete( iClient, iWlanReceiveFrameStatus, KErrNone );
 iWlanReceiveFrameStatus = NULL;
 }
 }
 // ---------------------------------------------------------------------------
 //
 void DWlanLogicalChannel::ReleaseIndicationListEntry(
 TIndicationListEntry* aEntry )
 {
-aEntry->next = NULL;
+if ( aEntry )
+{
-if ( !iFreeIndicationListHead )
+aEntry->next = NULL;
-{
-iFreeIndicationListHead = aEntry;
+if ( !iFreeIndicationListHead )
-}
+{
+iFreeIndicationListHead = aEntry;
+}
+else
+{
+TIndicationListEntry* tmp = iFreeIndicationListHead;
+while ( tmp->next )
+{
+tmp = tmp->next;
+}
+tmp->next = aEntry;
+}
+}
+#ifndef NDEBUG
 else
 {
-TIndicationListEntry* tmp = iFreeIndicationListHead;
+os_assert( (TUint8*)("WLANLDD: panic"), (TUint8*)(WLAN_FILE), __LINE__ );
+}
-while ( tmp->next )
+#endif
-{
-tmp = tmp->next;
-}
-tmp->next = aEntry;
-}
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------

changeset 22	c6a1762761b8
parent 17	41a8eba36f74
child 35	5e6ba967244f