--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitylayer/isce/isaaccessextension_dll/src/peptransceiver.cpp Fri Nov 06 17:28:23 2009 +0000
@@ -0,0 +1,1107 @@
+/*
+* Copyright (c) 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:
+*
+*/
+
+
+
+#include <PhonetIsi.h> // For phonet-header offsets like ISI_HEADER_OFFSET_MESSAGEID
+#include <pipeisi.h> // For PEP_IND_BUSY etc..
+#include <pipe_sharedisi.h> // For PN_MULTI_CREDIT_FLOW_CONTROL etc..
+#include <pn_const.h>
+
+#include "pep.h" // For DPep
+#include "peptransceiver.h"
+#include "iadtrace.h"
+#include "internalapi.h"
+#include "iadnokiadefinitions.h"
+#include "iadinternaldefinitions.h" // For CREDIT_.. and KIADChDataRx...
+#include "iadhelpers.h" // For GET_RECEIVER_.., GET_SENDER_... etc.. macros
+#include "router.h" // For DRouter
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "peptransceiverTraces.h"
+#endif
+
+const TUint8 KPnPipeSbPreferredFcRx( 0x08 );
+const TUint8 KPnPipeSbPreferredFcTx( 0x08 );
+
+const TInt KPepRespCommonErrorCodeOffset( 3 );
+const TInt KPnsPepRespPepErrorCode( ISI_HEADER_SIZE + KPepRespCommonErrorCodeOffset );
+const TInt KPnsPepStatusIndIndicationId( ISI_HEADER_SIZE + PNS_PEP_STATUS_IND_OFFSET_INDICATIONID );// 12
+const TInt KPnsPepStatusIndIndicationData( ISI_HEADER_SIZE + PNS_PEP_STATUS_IND_OFFSET_INDICATIONDATA );// 15
+
+const TInt KPnsPepRespLength( 12 );
+const TInt KPepRespReqIndCommonPipeHandleOffset( 2 ); // TODO: use offsets!
+
+// TODO: change this to use UniqueID of DThread instead and to extension
+void DPepTransceiver::CheckDfc()
+ {
+ OstTrace0( TRACE_PIPE, DPEPTRANSCEIVER_CHECKDFC_ENTRY, ">DPepTransceiver::CheckDfc" );
+
+ DObject* tempObj = reinterpret_cast<DObject*>( &Kern::CurrentThread() );
+ TUint8* buffer = ( TUint8* )Kern::Alloc( 100 );
+ TPtr8* bufferPtr = new ( TPtr8 )( buffer, 100 );
+ tempObj->Name( *bufferPtr );
+ C_TRACE( ( _T( "DRouter::CheckDfc" ) ) );
+ if ( bufferPtr->Compare( KIADExtensionDfc ) != KErrNone )
+ {
+ for( TInt i( 0 );i < bufferPtr->Length(); ++i )
+ {
+ C_TRACE( ( _T( "%c" ), i, bufferPtr->Ptr()[ i ] ) );
+ }
+ ASSERT_RESET_ALWAYS( 0, EIADWrongDFCQueueUsed | EIADFaultIdentifier4 << KFaultIdentifierShift );
+ }
+ Kern::Free( buffer );
+ delete bufferPtr;
+ bufferPtr = NULL;
+
+ OstTrace0( TRACE_PIPE, DPEPTRANSCEIVER_CHECKDFC_EXIT, "<DPepTransceiver::CheckDfc" );
+ }
+
+#ifdef _DEBUG
+#define ASSERT_DFCTHREAD_INEXT() CheckDfc()
+#else
+#define ASSERT_DFCTHREAD_INEXT()
+#endif
+
+DPepTransceiver::DPepTransceiver(
+ DRouter* aRouter,
+ MIAD2ChannelApi* aUl
+ ):
+ iFlowCtrl( EIADFlowControlOn ),
+ iPipeHandle( 0x00 ),
+ iRouter( aRouter ),
+ iRcvChannel( aUl )
+ {
+ OstTraceExt2( TRACE_PIPE, DPEPTRANSCEIVER_DPEPTRANSCEIVER_ENTRY, ">DPepTransceiver::DPepTransceiver;aRouter=%x;aUl=%x", ( TUint )( aRouter ), ( TUint )( aUl ) );
+
+ C_TRACE( ( _T( "DPepTransceiver::DPepTransceiver pipehandle 0x%x ->" ), iPipeHandle ) );
+ ASSERT_RESET_ALWAYS( iRcvChannel && iRouter, EIADNullParameter | EIADFaultIdentifier13 << KFaultIdentifierShift );
+ C_TRACE( ( _T( "DPepTransceiver::DPepTransceiver <-" ) ) );
+
+ OstTraceExt2( TRACE_PIPE, DPEPTRANSCEIVER_DPEPTRANSCEIVER_EXIT, "<DPepTransceiver::DPepTransceiver;aRouter=%x;aUl=%x", ( TUint )( aRouter ), ( TUint )( aUl ) );
+ }
+
+DPepTransceiver::DPepTransceiver(
+ TUint8 aPipeHandle
+ ):
+ iFlowCtrl( EIADFlowControlOn ),
+ iPipeHandle( aPipeHandle ),
+ iRouter( NULL ),
+ iRcvChannel( NULL )
+ {
+ OstTraceExt1( TRACE_PIPE, DUP1_DPEPTRANSCEIVER_DPEPTRANSCEIVER_ENTRY, ">DPepTransceiver::DPepTransceiver;aPipeHandle=%hhu", aPipeHandle );
+ C_TRACE( ( _T( "DPepTransceiver::DPepTransceiver pipehandle 0x%x <->" ), iPipeHandle ) );
+ }
+
+DPepTransceiver::~DPepTransceiver()
+ {
+ OstTrace0( TRACE_PIPE, DUP2_DPEPTRANSCEIVER_DPEPTRANSCEIVER_ENTRY, ">DPepTransceiver::~DPepTransceiver" );
+ C_TRACE( ( _T( "DPepTransceiver::~DPepTransceiver ->" ) ) );
+ iFlowCtrl = EIADFlowControlOn;
+ iPipeHandle = 0x00;
+ iChannelId = 0x0000;
+ iRouter = NULL;
+ iRcvChannel = NULL;
+ C_TRACE( ( _T( "DPepTransceiver::~DPepTransceiver <-" ) ) );
+ OstTrace0( TRACE_PIPE, DUP2_DPEPTRANSCEIVER_DPEPTRANSCEIVER_EXIT, "<DPepTransceiver::~DPepTransceiver" );
+ }
+
+void DPepTransceiver::SetFlowCtrl(
+ TIADFlowControlStatus aFlow
+ )
+ {
+ OstTrace1( TRACE_PIPE, DPEPTRANSCEIVER_SETFLOWCTRL_ENTRY, ">DPepTransceiver::SetFlowCtrl;aFlow=%x", ( TUint )&( aFlow ) );
+
+ C_TRACE( ( _T( "DPepTransceiver::SetFlowCtrl > %d ->" ), aFlow ) );
+ iRcvChannel->NotifyFlowCtrl( aFlow );
+ C_TRACE( ( _T( "DPepTransceiver::SetFlowCtrl > %d <-" ), aFlow ) );
+
+ OstTrace1( TRACE_PIPE, DPEPTRANSCEIVER_SETFLOWCTRL_EXIT, "<DPepTransceiver::SetFlowCtrl;aFlow=%x", ( TUint )&( aFlow ) );
+ }
+#if (NCP_COMMON_SOS_VERSION_SUPPORT >= SOS_VERSION_95)
+void DPepTransceiver::SetMyChannel(
+ MIAD2ChannelApi* aCh
+ )
+ {
+
+ C_TRACE( ( _T( "DPepTransceiver::SetMyChannel old 0x%x new 0x%x this 0x%x ->" ), iRcvChannel, aCh, this ) );
+ OstTraceExt3( TRACE_PIPE, DPEPTRANSCEIVER_SETMYCHANNEL_ENTRY, ">DPepTransceiver::SetMyChannel;old=%x;new=%x;this=%x", (TUint)iRcvChannel, (TUint)aCh, (TUint)this );
+ ASSERT_RESET_ALWAYS( aCh, 0 );//TODO
+ iRcvChannel = aCh;
+ C_TRACE( ( _T( "DPepTransceiver::SetMyChannel old 0x%x new 0x%x this 0x%x <-" ), iRcvChannel, aCh, this ) );
+ OstTraceExt3( TRACE_PIPE, DPEPTRANSCEIVER_SETMYCHANNEL_EXIT, "<DPepTransceiver::SetMyChannel;old=%x;new=%x;this=%x", (TUint)iRcvChannel, (TUint)aCh, (TUint)this );
+
+ }
+#endif
+
+DPepRx::~DPepRx()
+ {
+ OstTrace0( TRACE_PIPE, DPEPRX_DPEPRX_ENTRY, ">DPepRx::~DPepRx" );
+ C_TRACE( ( _T( "DPepRx::~DPepRx ->" ) ) );
+//TBR iReceiveQueueCount = 0x00;
+ C_TRACE( ( _T( "DPepRx::~DPepRx <-" ) ) );
+ }
+
+DPepTx::~DPepTx()
+ {
+ OstTrace0( TRACE_PIPE, DPEPTX_DPEPTX_ENTRY, ">DPepTx::~DPepTx" );
+ C_TRACE( ( _T( "DPepTx::~DPepTx ->" ) ) );
+ C_TRACE( ( _T( "DPepTx::~DPepTx <-" ) ) );
+ }
+
+DMultiRx::~DMultiRx()
+ {
+ OstTrace0( TRACE_PIPE, DMULTIRX_DMULTIRX_ENTRY, ">DMultiRx::~DMultiRx" );
+ C_TRACE( ( _T( "DMultiRx::~DMultiRx ->" ) ) );
+ iThresholdCount = 0x00;
+#ifdef _DEBUG // TODO: remove debug flag from actual code.
+ iGrantedCreditCount = 0x00;
+#endif
+ C_TRACE( ( _T( "DMultiRx::~DMultiRx <-" ) ) );
+ OstTrace0( TRACE_PIPE, DMULTIRX_DMULTIRX_EXIT, "<DMultiRx::~DMultiRx" );
+ }
+
+DLegacyRx::~DLegacyRx()
+ {
+ OstTrace0( TRACE_PIPE, DLEGACYRX_DLEGACYRX_ENTRY, ">DLegacyRx::~DLegacyRx" );
+ C_TRACE( ( _T( "DLegacyRx::~DLegacyRx ->" ) ) );
+ iRxQueueCount = 0x00;
+ C_TRACE( ( _T( "DLegacyRx::~DLegacyRx <-" ) ) );
+ OstTrace0( TRACE_PIPE, DLEGACYRX_DLEGACYRX_EXIT, "<DLegacyRx::~DLegacyRx" );
+ }
+
+DOneRx::~DOneRx()
+ {
+ OstTrace0( TRACE_PIPE, DONERX_DONERX_ENTRY, ">DOneRx::~DOneRx" );
+ C_TRACE( ( _T( "DOneRx::~DOneRx ->" ) ) );
+ C_TRACE( ( _T( "DOneRx::DOneRx TBR pipehandle 0x%x" ), iPipeHandle ) ); // TBR
+
+ C_TRACE( ( _T( "DOneRx::~DOneRx <-" ) ) );
+ OstTrace0( TRACE_PIPE, DONERX_DONERX_EXIT, "<DOneRx::~DOneRx" );
+ }
+
+DMultiTx::~DMultiTx()
+ {
+ OstTrace0( TRACE_PIPE, DMULTITX_DMULTITX_ENTRY, ">DMultiTx::~DMultiTx" );
+ C_TRACE( ( _T( "DMultiRx::~DMultiRx ->" ) ) );
+ iGrantedCredits = 0x00;
+ C_TRACE( ( _T( "DMultiRx::~DMultiRx <-" ) ) );
+ OstTrace0( TRACE_PIPE, DMULTITX_DMULTITX_EXIT, "<DMultiTx::~DMultiTx" );
+ }
+
+DLegacyTx::~DLegacyTx()
+ {
+ OstTrace0( TRACE_PIPE, DLEGACYTX_DLEGACYTX_ENTRY, ">DLegacyTx::~DLegacyTx" );
+ C_TRACE( ( _T( "DLegacyRx::~DLegacyRx ->" ) ) );
+ C_TRACE( ( _T( "DLegacyRx::~DLegacyRx <-" ) ) );
+ }
+
+DOneTx::~DOneTx()
+ {
+ OstTrace0( TRACE_PIPE, DONETX_DONETX_ENTRY, ">DOneTx::~DOneTx" );
+ C_TRACE( ( _T( "DOneTx::~DOneRx ->" ) ) );
+ C_TRACE( ( _T( "DOneTx::~DOneRx <-" ) ) );
+ }
+
+
+TInt DPepTransceiver::SendPnsPepConnectResp(
+ const TDesC8& aReq
+ )
+ {
+ OstTraceExt2( TRACE_PIPE, DPEPTRANSCEIVER_SENDPNSPEPCONNECTRESP_ENTRY, ">DPepTransceiver::SendPnsPepConnectResp;aReq=%x;iPipeHandle=%x", ( TUint )&( aReq ), iPipeHandle );
+
+ C_TRACE( ( _T( "DPepTransceiver::SendConnectResp -" ) ) );
+ const TUint8* temp( aReq.Ptr() );
+ ASSERT_RESET_ALWAYS( aReq.Length() > ISI_HEADER_SIZE + PNS_PEP_CONNECT_REQ_OFFSET_PIPEHANDLE, EIADOverTheLimits | EIADFaultIdentifier14 << KFaultIdentifierShift );
+ iChannelId = GET_RECEIVER_OBJ( temp );
+ iPipeHandle = temp[ ISI_HEADER_SIZE + PNS_PEP_CONNECT_REQ_OFFSET_PIPEHANDLE ]; // TODO: pipehandle checking
+ C_TRACE( ( _T( "DPepTransceiver::SendConnectResp pipehandle 0x%x" ), iPipeHandle ) );
+ const TInt KPnsPepConnectRespLength( ISI_HEADER_SIZE + SIZE_PNS_PEP_CONNECT_RESP + KPnPipeSbPreferredFcRx + KPnPipeSbPreferredFcTx );
+ TDes8& resp = CreateCommonPepResp( aReq, KPnsPepConnectRespLength, PNS_PEP_CONNECT_RESP );
+ TUint8* msgPtr( const_cast<TUint8*>( resp.Ptr() ) );
+ msgPtr[ ISI_HEADER_SIZE + PNS_PEP_CONNECT_RESP_OFFSET_ERRORCODE ] = PN_PIPE_NO_ERROR;// TODO: all pipes in use
+ msgPtr[ ISI_HEADER_SIZE + PNS_PEP_CONNECT_RESP_OFFSET_FILLERBYTE1 ] = 0x00;
+ msgPtr[ ISI_HEADER_SIZE + PNS_PEP_CONNECT_RESP_OFFSET_FILLERBYTE2 ] = 0x00;
+ msgPtr[ ISI_HEADER_SIZE + PNS_PEP_CONNECT_RESP_OFFSET_FILLERBYTE3 ] = 0x00;
+ msgPtr[ ISI_HEADER_SIZE + PNS_PEP_CONNECT_RESP_OFFSET_NSB ] = 0x02;
+// SB0
+ TUint16 headerAndMsgSize( ISI_HEADER_SIZE + SIZE_PNS_PEP_CONNECT_RESP );
+ msgPtr[ headerAndMsgSize + PN_PIPE_SB_PREFERRED_FC_RX_OFFSET_SBID ] = PN_PIPE_SB_PREFERRED_FC_RX;
+ msgPtr[ headerAndMsgSize + PN_PIPE_SB_PREFERRED_FC_RX_OFFSET_SBLEN ] = KPnPipeSbPreferredFcRx;
+ msgPtr[ headerAndMsgSize + PN_PIPE_SB_PREFERRED_FC_RX_OFFSET_PREFERREDFCRXLENGTH ] = 0x03;
+ msgPtr[ headerAndMsgSize + PN_PIPE_SB_PREFERRED_FC_RX_OFFSET_FILLERBYTE1 ] = 0x00;
+ C_TRACE( ( _T( "DPepTransceiver::SendConnectResp preferred RX 1st multi 2nd legacy 3rd one" )) );
+ OstTrace0( TRACE_PIPE, DPEPTRANSCEIVER_SENDPNSPEPCONNECTRESP_PREF_RX, "DPepTransceiver::SendPnsPepConnectResp preferred RX 1st muslt 2nd legacy 3rd one" );
+
+ msgPtr[ headerAndMsgSize + PN_PIPE_SB_PREFERRED_FC_RX_OFFSET_PREFERREDFCRX ] = PN_MULTI_CREDIT_FLOW_CONTROL; // 1st
+ msgPtr[ headerAndMsgSize + PN_PIPE_SB_PREFERRED_FC_RX_OFFSET_PREFERREDFCRX + 1 ] = PN_LEGACY_FLOW_CONTROL; // 2nd
+ msgPtr[ headerAndMsgSize + PN_PIPE_SB_PREFERRED_FC_RX_OFFSET_PREFERREDFCRX + 2 ] = PN_ONE_CREDIT_FLOW_CONTROL; // 3rd
+ msgPtr[ headerAndMsgSize + PN_PIPE_SB_PREFERRED_FC_RX_OFFSET_PREFERREDFCRX + 3 ] = 0x00; // filler
+//SB1
+ TUint16 headerMsgAndSbSize( headerAndMsgSize + KPnPipeSbPreferredFcRx );
+ msgPtr[ headerMsgAndSbSize + PN_PIPE_SB_REQUIRED_FC_TX_OFFSET_SBID ] = PN_PIPE_SB_REQUIRED_FC_TX;
+ msgPtr[ headerMsgAndSbSize + PN_PIPE_SB_REQUIRED_FC_TX_OFFSET_SBLEN ] = KPnPipeSbPreferredFcTx;
+ msgPtr[ headerMsgAndSbSize + PN_PIPE_SB_REQUIRED_FC_TX_OFFSET_REQUIREDFCTXLENGTH ] = 0x03;
+ msgPtr[ headerMsgAndSbSize + PN_PIPE_SB_REQUIRED_FC_TX_OFFSET_FILLERBYTE1 ] = 0x00;
+ C_TRACE( ( _T( "DPepTransceiver::SendConnectResp preferred TX 1st multi 2nd legacy 3rd one" )) );
+ OstTrace0( TRACE_PIPE, DPEPTRANSCEIVER_SENDPNSPEPCONNECTRESP_PREF_TX, "DPepTransceiver::SendPnsPepConnectResp preferred TX 1st multi 2nd legacy 3rd one" );
+ msgPtr[ headerMsgAndSbSize + PN_PIPE_SB_REQUIRED_FC_TX_OFFSET_REQUIREDFCTX ] = PN_MULTI_CREDIT_FLOW_CONTROL; // 1st
+ msgPtr[ headerMsgAndSbSize + PN_PIPE_SB_REQUIRED_FC_TX_OFFSET_REQUIREDFCTX + 1 ] = PN_LEGACY_FLOW_CONTROL; // 2nd
+ msgPtr[ headerMsgAndSbSize + PN_PIPE_SB_REQUIRED_FC_TX_OFFSET_REQUIREDFCTX + 2 ] = PN_ONE_CREDIT_FLOW_CONTROL; // 3rd
+ msgPtr[ headerMsgAndSbSize + PN_PIPE_SB_REQUIRED_FC_TX_OFFSET_REQUIREDFCTX + 3 ] = 0x00; // filler
+ ASSERT_RESET_ALWAYS( resp.Length() > ( headerMsgAndSbSize + PN_PIPE_SB_REQUIRED_FC_TX_OFFSET_REQUIREDFCTX + 3 ), EIADOverTheLimits | EIADFaultIdentifier15 << KFaultIdentifierShift );
+
+ C_TRACE( ( _T( "DPepTransceiver::SendConnectResp <-" ) ) );
+ TInt retVal = iRouter->SendMsg( resp );
+
+ OstTrace1( TRACE_PIPE, DPEPTRANSCEIVER_SENDPNSPEPCONNECTRESP_EXIT, "<DPepTransceiver::SendPnsPepConnectResp;retVal=%d", retVal );
+ return retVal;
+ }
+
+TInt DPepTransceiver::SendResetResp(
+ const TDesC8& aReq
+ )
+ {
+ OstTrace1( TRACE_PIPE, DPEPTRANSCEIVER_SENDRESETRESP_ENTRY, ">DPepTransceiver::SendResetResp;aReq=%x", ( TUint )&( aReq ) );
+
+ C_TRACE( ( _T( "DPepTransceiver::SendResetResp ->" ) ) );
+ ASSERT_RESET_ALWAYS( aReq.Ptr()[ ISI_HEADER_SIZE + PNS_PIPE_RESET_RESP_OFFSET_PIPEHANDLE ] == iPipeHandle, EIADWrongPipeHandle | EIADFaultIdentifier2 << KFaultIdentifierShift );
+ TDes8& resp = CreateCommonPepResp( aReq, KPnsPepRespLength, PNS_PEP_RESET_RESP);
+ TUint8* msgPtr( const_cast<TUint8*>( resp.Ptr() ) );
+ msgPtr[ KPnsPepRespPepErrorCode ] = PN_PIPE_NO_ERROR;
+ ASSERT_RESET_ALWAYS( resp.Length() > ( KPnsPepRespPepErrorCode ), EIADOverTheLimits | EIADFaultIdentifier16 << KFaultIdentifierShift );
+ C_TRACE( ( _T( "DPepTransceiver::SendResetResp <-" ) ) );
+ TInt retVal = iRouter->SendMsg( resp );
+
+ OstTrace1( TRACE_PIPE, DPEPTRANSCEIVER_SENDRESETRESP_EXIT, "<DPepTransceiver::SendResetResp;retVal=%d", retVal );
+ return retVal;
+ }
+
+TInt DPepTransceiver::SendPnsPepDisconnectResp(
+ const TDesC8& aReq
+ )
+ {
+ OstTrace1( TRACE_PIPE, DPEPTRANSCEIVER_SENDPNSPEPDISCONNECTRESP_ENTRY, ">DPepTransceiver::SendPnsPepDisconnectResp;aReq=%x", ( TUint )&( aReq ) );
+
+ C_TRACE( ( _T( "DPepTransceiver::SendDisconnectResp 0x%x ->" ), &aReq ) );
+ ASSERT_RESET_ALWAYS( aReq.Ptr()[ ISI_HEADER_SIZE + PNS_PEP_DISCONNECT_RESP_OFFSET_PIPEHANDLE ] == iPipeHandle, EIADWrongPipeHandle | EIADFaultIdentifier3 << KFaultIdentifierShift );
+ iRcvChannel->NotifyFlowCtrl( EIADTransmissionEnd );
+ TUint16 size( ISI_HEADER_SIZE + SIZE_PNS_PEP_DISCONNECT_RESP );
+ TDes8& resp = CreateCommonPepResp( aReq, size, PNS_PEP_DISCONNECT_RESP );
+ TUint8* msgPtr( const_cast<TUint8*>( resp.Ptr() ) );
+ msgPtr[ ISI_HEADER_SIZE + PNS_PEP_DISCONNECT_RESP_OFFSET_ERRORCODE ] = PN_PIPE_NO_ERROR;
+ ASSERT_RESET_ALWAYS( resp.Length() > ( ISI_HEADER_SIZE + PNS_PEP_DISCONNECT_RESP_OFFSET_ERRORCODE ), EIADOverTheLimits | EIADFaultIdentifier17 << KFaultIdentifierShift );
+ C_TRACE( ( _T( "DPepTransceiver::SendDisconnectResp 0x%x <-" ), &aReq ) );
+ TInt retVal = iRouter->SendMsg( resp );
+
+ OstTrace1( TRACE_PIPE, DPEPTRANSCEIVER_SENDPNSPEPDISCONNECTRESP_EXIT, "<DPepTransceiver::SendPnsPepDisconnectResp;retVal=%d", retVal );
+ return retVal;
+ }
+
+TInt DPepTransceiver::SendEnableResp(
+ const TDesC8& aReq
+ )
+ {
+ OstTrace1( TRACE_PIPE, DPEPTRANSCEIVER_SENDENABLERESP_ENTRY, ">DPepTransceiver::SendEnableResp;aReq=%x", ( TUint )&( aReq ) );
+
+ C_TRACE( ( _T( "DPepTransceiver::SendEnableResp ->" ) ) );
+ ASSERT_RESET_ALWAYS( aReq.Ptr()[ ISI_HEADER_SIZE + PNS_PIPE_ENABLE_REQ_OFFSET_PIPEHANDLE ] == iPipeHandle, EIADWrongPipeHandle | EIADFaultIdentifier4 << KFaultIdentifierShift );
+ TDes8& resp = CreateCommonPepResp(aReq, KPnsPepRespLength, PNS_PEP_ENABLE_RESP);
+ TUint8* msgPtr( const_cast<TUint8*>( resp.Ptr() ) );
+ msgPtr[ KPnsPepRespPepErrorCode ] = PN_PIPE_NO_ERROR;
+ ASSERT_RESET_ALWAYS( resp.Length() > ( KPnsPepRespPepErrorCode ), EIADOverTheLimits | EIADFaultIdentifier18 << KFaultIdentifierShift );
+ C_TRACE( ( _T( "DPepTransceiver::SendEnableResp <-" ) ) );
+ TInt retVal = iRouter->SendMsg( resp );
+
+ OstTrace1( TRACE_PIPE, DPEPTRANSCEIVER_SENDENABLERESP_EXIT, "<DPepTransceiver::SendEnableResp;retVal=%d", retVal );
+ return retVal;
+ }
+
+TInt DPepTransceiver::SendDisableResp(
+ const TDesC8& aReq
+ )
+ {
+ OstTrace1( TRACE_PIPE, DPEPTRANSCEIVER_SENDDISABLERESP_ENTRY, ">DPepTransceiver::SendDisableResp;aReq=%x", ( TUint )&( aReq ) );
+
+ C_TRACE( ( _T( "DPepTransceiver::SendDisableResp ->" ) ) );
+ ASSERT_RESET_ALWAYS( aReq.Ptr()[ ISI_HEADER_SIZE + PNS_PEP_DISABLE_REQ_OFFSET_PIPEHANDLE ] == iPipeHandle, EIADWrongPipeHandle | EIADFaultIdentifier5 << KFaultIdentifierShift );
+ TDes8& resp = CreateCommonPepResp(aReq, KPnsPepRespLength, PNS_PEP_DISABLE_RESP);
+ TUint8* msgPtr( const_cast<TUint8*>( resp.Ptr() ) );
+ msgPtr[ KPnsPepRespPepErrorCode ] = PN_PIPE_NO_ERROR;
+ ASSERT_RESET_ALWAYS( resp.Length() > ( KPnsPepRespPepErrorCode ), EIADOverTheLimits | EIADFaultIdentifier19 << KFaultIdentifierShift );
+ C_TRACE( ( _T( "DPepTransceiver::SendDisableResp <-" ) ) );
+ TInt retVal = iRouter->SendMsg( resp );
+
+ OstTrace1( TRACE_PIPE, DPEPTRANSCEIVER_SENDDISABLERESP_EXIT, "<DPepTransceiver::SendDisableResp;retVal=%d", retVal );
+ return retVal;
+ }
+
+TInt DPepTransceiver::PepControlReq(
+ const TDesC8& aReq
+ )
+ {
+ OstTrace1( TRACE_PIPE, DPEPTRANSCEIVER_PEPCONTROLREQ_ENTRY, ">DPepTransceiver::PepControlReq;aReq=%x", ( TUint )&( aReq ) );
+
+ C_TRACE( ( _T( "DPepTransceiver::PepControlReq ->" ) ) );
+ const TUint8* reqPtr( aReq.Ptr() );
+ ASSERT_RESET_ALWAYS( reqPtr[ ISI_HEADER_SIZE + PNS_PEP_CTRL_RESP_OFFSET_PIPEHANDLE ] == iPipeHandle, EIADWrongPipeHandle | EIADFaultIdentifier6 << KFaultIdentifierShift );
+ ASSERT_RESET_ALWAYS( reqPtr[ ISI_HEADER_SIZE + PNS_PEP_CTRL_REQ_OFFSET_PEPTYPE ] == PN_PEP_TYPE_COMMON, EIADUnknownPipeOrPepMsg | EIADFaultIdentifier2 << KFaultIdentifierShift );
+ TDes8& resp = CreateCommonPepResp( aReq, (ISI_HEADER_SIZE + SIZE_PNS_PEP_CTRL_RESP), PNS_PEP_CTRL_RESP );
+ TUint8* msgPtr( const_cast<TUint8*>( resp.Ptr() ) );
+ msgPtr[ ISI_HEADER_SIZE + PNS_PEP_CTRL_RESP_OFFSET_PEPCTRLID ] = reqPtr[ ISI_HEADER_SIZE + PNS_PEP_CTRL_REQ_OFFSET_PEPCTRLID ];
+ msgPtr[ ISI_HEADER_SIZE + PNS_PEP_CTRL_RESP_OFFSET_PEPTYPE ] = PN_PEP_TYPE_COMMON;// IAD Supports only common peps.
+ msgPtr[ ISI_HEADER_SIZE + PNS_PEP_CTRL_RESP_OFFSET_ERRORCODE ] = PN_PIPE_NO_ERROR;
+ ASSERT_RESET_ALWAYS( resp.Length() > ( ISI_HEADER_SIZE + PNS_PEP_CTRL_RESP_OFFSET_ERRORCODE ), EIADOverTheLimits | EIADFaultIdentifier43 << KFaultIdentifierShift );
+ C_TRACE( ( _T( "DPepTransceiver::PepControlReq <-" ) ) );
+ TInt retVal = iRouter->SendMsg( resp );
+
+ OstTrace1( TRACE_PIPE, DPEPTRANSCEIVER_PEPCONTROLREQ_EXIT, "<DPepTransceiver::PepControlReq;retVal=%d", retVal );
+ return retVal;
+ }
+
+TInt DPepTransceiver::Receive(
+ const TDesC8& aData
+ )
+ {
+ OstTrace1( TRACE_PIPE, DPEPTRANSCEIVER_RECEIVE_ENTRY, ">DPepTransceiver::Receive;aData=%x", ( TUint )&( aData ) );
+
+ C_TRACE( ( _T( "DPepTransceiver::Receive ->" ) ) );
+ ASSERT_RESET_ALWAYS( aData.Length() > ( ISI_HEADER_SIZE + PNS_PIPE_DATA_OFFSET_PIPEHANDLE ), EIADOverTheLimits | EIADFaultIdentifier20 << KFaultIdentifierShift );
+ ASSERT_RESET_ALWAYS( aData.Ptr()[ ISI_HEADER_SIZE + PNS_PIPE_DATA_OFFSET_PIPEHANDLE ] == iPipeHandle, EIADWrongPipeHandle | EIADFaultIdentifier7 << KFaultIdentifierShift );
+#if (NCP_COMMON_SOS_VERSION_SUPPORT >= SOS_VERSION_95)
+ C_TRACE( ( _T( "DPepTransceiver::Receive new 0x%x this 0x%x" ), iRcvChannel, this ) );
+ OstTraceExt2( TRACE_PIPE, DPEPTRANSCEIVER_RECEIVE, "DPepTransceiver::Receive;new=%x;this=%x", ( TUint )iRcvChannel, (TUint) this );
+#endif
+ iRcvChannel->ReceiveDataMsg( aData );//PipeHeader is extracted in Channel
+ // TODO: if changed so that header is extracted here
+ C_TRACE( ( _T( "DPepTransceiver::Receive <-" ) ) );
+ TInt retVal = KErrNone;//TODO
+
+ OstTrace0( TRACE_PIPE, DPEPTRANSCEIVER_RECEIVE_EXIT, "<DPepTransceiver::Receive" );
+ return retVal;
+ }
+
+TInt DPepTransceiver::Send(TDes8& aMsg)
+ {
+ OstTrace1( TRACE_PIPE, DPEPTRANSCEIVER_SEND_ENTRY, ">DPepTransceiver::Send;aMsg=%x", ( TUint )&( aMsg ) );
+
+ C_TRACE( ( _T( "DPepTransceiver::Send <->" ) ) );
+ TInt retVal = iRouter->SendMsg(aMsg);
+
+ OstTrace0( TRACE_PIPE, DPEPTRANSCEIVER_SEND_EXIT, "<DPepTransceiver::Send" );
+ return retVal;
+ }
+
+TDes8& DPepTransceiver::CreateCommonPepResp(
+ const TDesC8& aReq,
+ const TUint16 aLength,
+ const TUint8 aMsgId
+ )
+ {
+ OstTraceExt3( TRACE_PIPE, DPEPTRANSCEIVER_CREATECOMMONPEPRESP_ENTRY, ">DPepTransceiver::CreateCommonPepResp;aReq=%x;aLength=%hu;aMsgId=%hhu", ( TUint )&( aReq ), aLength, aMsgId );
+
+ C_TRACE( ( _T( "DPepTransceiver::CreateCommonPepResp 0x%x 0x%x %d ->" ), &aReq, aMsgId, aLength ) );
+ TDes8& des = iRouter->AllocateBlock( aLength );
+ des.SetLength( aLength );
+ TUint8* req( const_cast<TUint8*>( aReq.Ptr() ) );
+ TUint8* msgPtr( const_cast<TUint8*>( des.Ptr() ) );
+ msgPtr[ ISI_HEADER_OFFSET_MEDIA ] = req[ ISI_HEADER_OFFSET_MEDIA ];
+ msgPtr[ ISI_HEADER_OFFSET_SENDERDEVICE ] = GET_RECEIVER_DEV( req );
+ msgPtr[ ISI_HEADER_OFFSET_RECEIVERDEVICE ] = GET_SENDER_DEV( req );
+ msgPtr[ ISI_HEADER_OFFSET_RESOURCEID ] = req[ ISI_HEADER_OFFSET_RESOURCEID ];
+ msgPtr[ ISI_HEADER_OFFSET_SENDEROBJECT ] = GET_RECEIVER_OBJ( req );
+ msgPtr[ ISI_HEADER_OFFSET_RECEIVEROBJECT ] = GET_SENDER_OBJ( req );
+ msgPtr[ ISI_HEADER_OFFSET_TRANSID ] = req[ ISI_HEADER_OFFSET_TRANSID ];
+ msgPtr[ ISI_HEADER_OFFSET_MESSAGEID ] = aMsgId;
+ SET_LENGTH( msgPtr, aLength - PN_HEADER_SIZE ); // ISI length
+ msgPtr[ ISI_HEADER_SIZE + KPepRespReqIndCommonPipeHandleOffset ] = iPipeHandle; // TODO: to offsets
+ ASSERT_RESET_ALWAYS( des.Length() > ( ISI_HEADER_SIZE + KPepRespReqIndCommonPipeHandleOffset ), EIADOverTheLimits | EIADFaultIdentifier21 << KFaultIdentifierShift );
+ C_TRACE( ( _T( "DPepTransceiver::CreateCommonPepResp 0x%x 0x%x %d <-" ), &aReq, aMsgId, aLength ) );
+
+ OstTrace1( TRACE_PIPE, DPEPTRANSCEIVER_CREATECOMMONPEPRESP_EXIT, "<DPepTransceiver::CreateCommonPepResp;des=%x", (TUint)&(des) );
+ return des;
+ }
+
+void DPepTransceiver::RegisterDataMsgStatusCb(MDataMessageStatus* aCb)
+ {
+ OstTrace1( TRACE_PIPE, DPEPTRANSCEIVER_REGISTERDATAMSGSTATUSCB_ENTRY, ">DPepTransceiver::RegisterDataMsgStatusCb;aCb=%x", ( TUint )( aCb ) );
+ C_TRACE( ( _T( "DPepTransceiver::RegisterDataMsgStatusCb ->" ) ) );
+ iRcvChannel->RegisterPep(*aCb);
+ C_TRACE( ( _T( "DPepTransceiver::RegisterDataMsgStatusCb <-" ) ) );
+ OstTrace0( TRACE_PIPE, DPEPTRANSCEIVER_REGISTERDATAMSGSTATUSCB_EXIT, "<DPepTransceiver::RegisterDataMsgStatusCb" );
+ }
+
+
+TDes8& DPepTransceiver::AllocateDataBlock(TUint16 aSize)
+ {
+ OstTraceExt1( TRACE_PIPE, DPEPTRANSCEIVER_ALLOCATEDATABLOCK_ENTRY, ">DPepTransceiver::AllocateDataBlock;aSize=%hu", aSize );
+ C_TRACE( ( _T( "DPepTransceiver::AllocateDataBlock ->" ) ) );
+ C_TRACE( ( _T( "DPepTransceiver::AllocateDataBlock <-" ) ) );
+ return iRouter->AllocateBlock( aSize);
+ }
+
+
+DOneTx::DOneTx(DPepTransceiver& aSuper, TUint8 aPipeHandle) : DPepTx(aSuper, aPipeHandle )
+ {
+ OstTraceExt2( TRACE_PIPE, DUP1_DONETX_DONETX_ENTRY, ">DOneTx::DOneTx;aSuper=%x;aPipeHandle=%hhu", ( TUint )&( aSuper ), aPipeHandle );
+ C_TRACE( ( _T( "DOneTx::DOneTx <->" ) ) );
+ }
+
+DMultiTx::DMultiTx(DPepTransceiver& aSuper, TUint8 aPipeHandle) : DPepTx(aSuper, aPipeHandle )
+ {
+ OstTraceExt2( TRACE_PIPE, DUP1_DMULTITX_DMULTITX_ENTRY, ">DMultiTx::DMultiTx;aSuper=%x;aPipeHandle=%hhu", ( TUint )&( aSuper ), aPipeHandle );
+ C_TRACE( ( _T( "DMultiTx::DMultiTx <->" ) ) );
+ }
+
+DLegacyTx::DLegacyTx(DPepTransceiver& aSuper, TUint8 aPipeHandle) : DPepTx(aSuper, aPipeHandle )
+ {
+ OstTraceExt2( TRACE_PIPE, DUP1_DLEGACYTX_DLEGACYTX_ENTRY, ">DLegacyTx::DLegacyTx;aSuper=%x;aPipeHandle=%hhu", ( TUint )&( aSuper ), aPipeHandle );
+ C_TRACE( ( _T( "DLegacyTx::DLegacyTx <->" ) ) );
+ }
+
+DOneRx::DOneRx( DPepTransceiver& aSuper, TUint8 aPipeHandle ) : DPepRx(aSuper, aPipeHandle )
+ {
+ OstTraceExt2( TRACE_PIPE, DUP1_DONERX_DONERX_ENTRY, ">DOneRx::DOneRx;aSuper=%x;aPipeHandle=%hhu", ( TUint )&( aSuper ), aPipeHandle );
+ C_TRACE( ( _T( "DOneRx::DOneRx ->" ) ) );
+ C_TRACE( ( _T( "DOneRx::DOneRx TBR pipehandle 0x%x" ), iPipeHandle ) ); // TBR
+ iSuper.RegisterDataMsgStatusCb(this);
+ C_TRACE( ( _T( "DOneRx::DOneRx <-" ) ) );
+ OstTrace0( TRACE_PIPE, DUP1_DONERX_DONERX_EXIT, "<DOneRx::DOneRx" );
+ }
+
+DMultiRx::DMultiRx(DPepTransceiver& aSuper, TUint8 aPipeHandle) : DPepRx(aSuper, aPipeHandle )
+ {
+ OstTraceExt2( TRACE_PIPE, DUP1_DMULTIRX_DMULTIRX_ENTRY, ">DMultiRx::DMultiRx;aSuper=%x;aPipeHandle=%hhu", ( TUint )&( aSuper ), aPipeHandle );
+ C_TRACE( ( _T( "DMultiRx::DMultiRx ->" ) ) );
+ iSuper.RegisterDataMsgStatusCb(this);
+ C_TRACE( ( _T( "DMultiRx::DMultiRx <-" ) ) );
+ OstTrace0( TRACE_PIPE, DUP1_DMULTIRX_DMULTIRX_EXIT, "<DMultiRx::DMultiRx" );
+ }
+
+DLegacyRx::DLegacyRx(DPepTransceiver& aSuper, TUint8 aPipeHandle) : DPepRx(aSuper, aPipeHandle )
+ {
+ OstTraceExt2( TRACE_PIPE, DUP1_DLEGACYRX_DLEGACYRX_ENTRY, ">DLegacyRx::DLegacyRx;aSuper=%x;aPipeHandle=%hhu", ( TUint )&( aSuper ), aPipeHandle );
+ C_TRACE( ( _T( "DLegacyRx::DLegacyRx ->" ) ) );
+ iSuper.RegisterDataMsgStatusCb(this);
+ C_TRACE( ( _T( "DLegacyRx::DLegacyRx <-" ) ) );
+ OstTrace0( TRACE_PIPE, DUP1_DLEGACYRX_DLEGACYRX_EXIT, "<DLegacyRx::DLegacyRx" );
+ }
+
+DPepRx::DPepRx(DPepTransceiver& aSuper, TUint8 aPipeHandle) : DPepTransceiver(aPipeHandle), iSuper(aSuper)
+ {
+ OstTraceExt2( TRACE_PIPE, DUP1_DPEPRX_DPEPRX_ENTRY, ">DPepRx::DPepRx;aSuper=%x;aPipeHandle=%hhu", ( TUint )&( aSuper ), aPipeHandle );
+ C_TRACE( ( _T( "DPepRx::DPepRx ->" ) ) );
+ C_TRACE( ( _T( "DPepRx::DPepRx <-" ) ) );
+ }
+
+#if (NCP_COMMON_SOS_VERSION_SUPPORT >= SOS_VERSION_95)
+void DPepRx::SetNewChannel(
+ MIAD2ChannelApi* aCh
+ )
+ {
+
+ C_TRACE( ( _T( "DPepRx::SetNewChannel new 0x%x this 0x%x ->" ), aCh, this ) );
+ OstTraceExt2( TRACE_PIPE, DUP1_DPEPRX_SETNEWCHANNEL_ENTRY, ">DPepRx::SetNewChannel;new=%x;this=%x", (TUint)aCh, (TUint)this );
+ iSuper.SetMyChannel( aCh );
+ iSuper.RegisterDataMsgStatusCb(this);
+ C_TRACE( ( _T( "DPepRx::SetNewChannel new 0x%x this 0x%x <-" ), aCh, this ) );
+ OstTraceExt2( TRACE_PIPE, DUP1_DPEPRX_SETNEWCHANNEL_EXIT, "<DPepRx::SetNewChannel;new=%x;this=%x", (TUint)aCh, (TUint)this );
+
+ }
+#endif
+// same behavior in all pipe types -> to base class
+// Actually not same behaviour -> child classes
+DPepTx::DPepTx(DPepTransceiver& aSuper, TUint8 aPipeHandle) : DPepTransceiver(aPipeHandle), iSuper(aSuper)
+ {
+ OstTraceExt2( TRACE_PIPE, DUP1_DPEPTX_DPEPTX_ENTRY, ">DPepTx::DPepTx;aSuper=%x;aPipeHandle=%hhu", ( TUint )&( aSuper ), aPipeHandle );
+ C_TRACE( ( _T( "DPepTx::DPepTx ->" ) ) );
+ C_TRACE( ( _T( "DPepTx::DPepTx <-" ) ) );
+ }
+
+void DPepTx::SetFlowCtrl(
+ TIADFlowControlStatus aFlow
+ )
+ {
+ OstTrace1( TRACE_PIPE, DPEPTX_SETFLOWCTRL_ENTRY, ">DPepTx::SetFlowCtrl;aFlow=%x", ( TUint )&( aFlow ) );
+
+ C_TRACE( ( _T( "DPepTx::SetFlowCtrl from %d to %d ->" ), iFlowCtrl, aFlow ) );
+ iSuper.SetFlowCtrl( aFlow );
+ iFlowCtrl = aFlow;
+ C_TRACE( ( _T( "DPepTx::SetFlowCtrl %d %d <-" ), iFlowCtrl, aFlow ) );
+
+ OstTrace0( TRACE_PIPE, DPEPTX_SETFLOWCTRL_EXIT, "<DPepTx::SetFlowCtrl" );
+ }
+
+void DOneTx::PipeEnabled(
+ // None
+ )
+ {
+ OstTrace0( TRACE_PIPE, DONETX_PIPEENABLED_ENTRY, "<>DOneTx::PipeEnabled" );
+
+ C_TRACE( ( _T( "DOneTx::PipeEnabled ->" ) ) );
+ // Do not set flow control off before credits are got.
+ C_TRACE( ( _T( "DOneTx::PipeEnabled <-" ) ) );
+
+ }
+
+void DMultiTx::PipeEnabled(
+ // None
+ )
+ {
+ OstTrace0( TRACE_PIPE, DMULTITX_PIPEENABLED_ENTRY, ">DMultiTx::PipeEnabled" );
+
+ C_TRACE( ( _T( "DMultiTx::PipeEnabled ->" ) ) );
+ // Do not set flow control off before credits are got.
+ if( iGrantedCredits > 0 && EIADFlowControlOn == iFlowCtrl )
+ {
+ SetFlowCtrl( EIADFlowControlOff );
+ //iSuper.SetFlowCtrl( EIADFlowControlOff );
+ }
+ C_TRACE( ( _T( "DMultiTx::PipeEnabled <-" ) ) );
+
+ OstTrace0( TRACE_PIPE, DMULTITX_PIPEENABLED_EXIT, "<DMultiTx::PipeEnabled" );
+ }
+
+void DLegacyTx::PipeEnabled(
+ // None
+ )
+ {
+ OstTrace0( TRACE_PIPE, DLEGACYTX_PIPEENABLED_ENTRY, ">DLegacyTx::PipeEnabled" );
+
+ C_TRACE( ( _T( "DLegacyTx::PipeEnabled ->" ) ) );
+ //iSuper.SetFlowCtrl( EIADFlowControlOff );
+ SetFlowCtrl( EIADFlowControlOff );
+ C_TRACE( ( _T( "DLegacyTx::PipeEnabled <-" ) ) );
+
+ OstTrace0( TRACE_PIPE, DLEGACYTX_PIPEENABLED_EXIT, "<DLegacyTx::PipeEnabled" );
+ }
+
+//same for legacy and one
+void DPepTx::PipeDisabled()
+ {
+ OstTrace0( TRACE_PIPE, DPEPTX_PIPEDISABLED_ENTRY, ">DPepTx::PipeDisabled" );
+ C_TRACE( ( _T( "DPepTx::PipeDisabled ->" ) ) );
+ //iSuper.SetFlowCtrl( EIADFlowControlOn );
+ SetFlowCtrl( EIADFlowControlOn );
+ C_TRACE( ( _T( "DPepTx::PipeDisabled <-" ) ) );
+ OstTrace0( TRACE_PIPE, DPEPTX_PIPEDISABLED_EXIT, "<DPepTx::PipeDisabled" );
+ }
+
+void DMultiTx::PipeDisabled(
+ // None
+ )
+ {
+ OstTrace0( TRACE_PIPE, DMULTITX_PIPEDISABLED_ENTRY, ">DMultiTx::PipeDisabled" );
+
+ C_TRACE( ( _T( "DMultiTx::PipeDisabled ->" ) ) );
+ iGrantedCredits = 0x00;
+ C_TRACE( ( _T( "DMultiTx::PipeDisabled discard TX credits 0x%x" ), iGrantedCredits ) );
+ //iSuper.SetFlowCtrl( EIADFlowControlOn );
+ SetFlowCtrl( EIADFlowControlOn );
+ C_TRACE( ( _T( "DMultiTx::PipeDisabled <-" ) ) );
+
+ OstTrace0( TRACE_PIPE, DMULTITX_PIPEDISABLED_EXIT, "<DMultiTx::PipeDisabled" );
+ }
+
+
+void DOneTx::PepStatusInd(
+ const TDesC8& aMessage
+ )
+ {
+ OstTrace1( TRACE_PIPE, DONETX_PEPSTATUSIND_ENTRY, ">DOneTx::PepStatusInd;aMessage=%x", ( TUint )&( aMessage ) );
+
+ C_TRACE( ( _T("DOneTx::PepStatusInd 0x%x ->" ), &aMessage ) );
+ const TUint8* ptr( aMessage.Ptr() );
+ // TODO: pipehandle info traceen
+ C_TRACE( ( _T("DOneTx::PepStatusInd msghandle 0x%x pipehandle 0x%x" ), ptr[ ISI_HEADER_SIZE + PNS_PEP_STATUS_IND_OFFSET_PIPEHANDLE ], iPipeHandle ) );
+ ASSERT_RESET_ALWAYS( ptr[ ISI_HEADER_SIZE + PNS_PEP_STATUS_IND_OFFSET_PIPEHANDLE ] == iPipeHandle, EIADWrongPipeHandle | EIADFaultIdentifier8 << KFaultIdentifierShift | (TUint8)iSuper.ChannelId()<<KChannelNumberShift);
+ TRACE_ASSERT_INFO( ptr[ KPnsPepStatusIndIndicationId ] == PN_PEP_IND_FLOW_CONTROL, (TUint8)iSuper.ChannelId()<<KChannelNumberShift );
+ TRACE_ASSERT_INFO( iFlowCtrl == EIADFlowControlOn, (TUint8)iSuper.ChannelId()<<KChannelNumberShift );
+ ASSERT_RESET_ALWAYS( aMessage.Length() > ( KPnsPepStatusIndIndicationData ), EIADOverTheLimits | EIADFaultIdentifier22 << KFaultIdentifierShift );
+ switch( ptr[ KPnsPepStatusIndIndicationData ] )
+ {
+ case PEP_IND_READY:
+ {
+ C_TRACE( ( _T("DOneTx::PepStatusInd got one credit" ) ) );
+ OstTrace0( TRACE_PIPE, DONETX_PEPSTATUSIND_ONE_CREDIT, "DOneTx::PepStatusInd got one credit" );
+ //iSuper.SetFlowCtrl( EIADFlowControlOff );
+ SetFlowCtrl( EIADFlowControlOff );
+ break;
+ }
+ default:
+ {
+ ASSERT_RESET_ALWAYS( 0, EIADNotSupported | EIADFaultIdentifier2 << KFaultIdentifierShift );
+ break;
+ }
+ }
+ C_TRACE( ( _T("DOneTx::PepStatusInd <-" ) ) );
+
+ OstTrace0( TRACE_PIPE, DONETX_PEPSTATUSIND_EXIT, "<DOneTx::PepStatusInd" );
+ }
+
+void DMultiTx::PepStatusInd(
+ const TDesC8& aMessage
+ )
+ {
+ OstTrace1( TRACE_PIPE, DMULTITX_PEPSTATUSIND_ENTRY, ">DMultiTx::PepStatusInd;aMessage=%x", ( TUint )&( aMessage ) );
+
+ C_TRACE( ( _T( "DMultiTx::HandlePnsPepStatusInd ->"), &aMessage) );
+ const TUint8* ptr( aMessage.Ptr() );
+ ASSERT_RESET_ALWAYS( aMessage.Length() > ( KPnsPepStatusIndIndicationId ), EIADOverTheLimits | EIADFaultIdentifier23 << KFaultIdentifierShift );
+ ASSERT_RESET_ALWAYS( ptr[ ISI_HEADER_SIZE + PNS_PEP_STATUS_IND_OFFSET_PIPEHANDLE ] == iPipeHandle, EIADWrongPipeHandle | EIADFaultIdentifier9 << KFaultIdentifierShift );
+ ASSERT_RESET_ALWAYS( ( ptr[ KPnsPepStatusIndIndicationId ] == PN_PEP_IND_MCFC_GRANT_CREDITS ), EIADWrongParameter | EIADFaultIdentifier8 << KFaultIdentifierShift );
+ const TUint8 granted( ptr[ KPnsPepStatusIndIndicationData ] );
+ C_TRACE( ( _T("DMultiTx::PepStatusInd TX credits old 0x%x granted 0x%x"), iGrantedCredits, granted ) );
+ // Assert if granted is zero, because then FlowControl setting don't work.
+ ASSERT_RESET_ALWAYS( 0x00 < granted, EIADWrongPipeHandle | EIADFaultIdentifier10 << KFaultIdentifierShift );
+ iGrantedCredits += granted;
+ C_TRACE( ( _T("DMultiTx::PepStatusInd TX credits new 0x%x"), iGrantedCredits ) );
+ OstTraceExt1( TRACE_PIPE, DMULTITX_PEPSTATUSIND_GRANTED, "DMultiTx::PepStatusInd TX credits new;iGrantedCredits=%hu", iGrantedCredits );
+
+ if( EIADFlowControlOn == iFlowCtrl )
+ {
+ SetFlowCtrl( EIADFlowControlOff );
+ //iSuper.SetFlowCtrl( EIADFlowControlOff );
+ }
+ C_TRACE( ( _T("DMultiTx::PepStatusInd <-") ) );
+
+ OstTrace0( TRACE_PIPE, DMULTITX_PEPSTATUSIND_EXIT, "<DMultiTx::PepStatusInd" );
+ }
+
+void DLegacyTx::PepStatusInd(
+ const TDesC8& aMessage
+ )
+ {
+ OstTrace1( TRACE_PIPE, DLEGACYTX_PEPSTATUSIND_ENTRY, ">DLegacyTx::PepStatusInd;aMessage=%x", ( TUint )&( aMessage ) );
+
+ C_TRACE( ( _T( "DLegacyTx::PepStatusInd ->" ) ) );
+ const TUint8* ptr( aMessage.Ptr() );
+ ASSERT_RESET_ALWAYS( aMessage.Length() > ( KPnsPepStatusIndIndicationData ), EIADOverTheLimits | EIADFaultIdentifier24 << KFaultIdentifierShift );
+ TRACE_ASSERT_INFO( ptr[ KPnsPepStatusIndIndicationId ] == PN_PEP_IND_FLOW_CONTROL, (TUint8)iSuper.ChannelId()<<KChannelNumberShift );
+ C_TRACE( ( _T("DIscIsiPep::HandlePnsPepStatusInd IndicationData 0x%x" ), ptr[ KPnsPepStatusIndIndicationData ] ) );
+ switch( ptr[ KPnsPepStatusIndIndicationData ] )
+ {
+ case PEP_IND_EMPTY:
+ case PEP_IND_READY:
+ {
+ SetFlowCtrl( EIADFlowControlOff );
+ //iSuper.SetFlowCtrl( EIADFlowControlOff );
+ break;
+ }
+ case PEP_IND_BUSY:
+ {
+ SetFlowCtrl( EIADFlowControlOn );
+ //iSuper.SetFlowCtrl( EIADFlowControlOn );
+ break;
+ }
+ default:
+ {
+ // TODO How about the PEP_IND_CREDIT?
+ ASSERT_RESET_ALWAYS( 0, EIADNotSupported | EIADFaultIdentifier1 << KFaultIdentifierShift | (TUint8)iSuper.ChannelId()<<KChannelNumberShift );
+ break;
+ }
+ }
+ C_TRACE( ( _T( "DLegacyTx::PepStatusInd <-" ) ) );
+ OstTrace0( TRACE_PIPE, DLEGACYTX_PEPSTATUSIND_EXIT, "<DLegacyTx::PepStatusInd" );
+ }
+
+ // From MDataMessageStatus
+void DOneRx::DataMessageDelivered()
+ {
+ OstTrace0( TRACE_PIPE, DONERX_DATAMESSAGEDELIVERED_ENTRY, ">DOneRx::DataMessageDelivered" );
+ C_TRACE( ( _T( "DOneRx::DataMessageDelivered ->" ) ) );
+ ASSERT_DFCTHREAD_INEXT();
+ SendOneCredit();
+ C_TRACE( ( _T( "DOneRx::DataMessageDelivered <->" ) ) );
+ OstTrace0( TRACE_PIPE, DONERX_DATAMESSAGEDELIVERED_EXIT, "<DOneRx::DataMessageDelivered" );
+ }
+
+void DLegacyRx::DataMessageDelivered(
+ // None
+ )
+ {
+ OstTrace0( TRACE_PIPE, DLEGACYRX_DATAMESSAGEDELIVERED_ENTRY, ">DLegacyRx::DataMessageDelivered" );
+
+ C_TRACE( ( _T( "DLegacyRx::DataMessageDelivered %d %d %d ->" ), iRxQueueCount, KIADChDataRxLowWaterMark, iFlowCtrl ) );
+ ASSERT_DFCTHREAD_INEXT();
+ iRxQueueCount--;
+ // TODO: remove iFlowCtrl (UL) not datames.. counts DL direction messages
+ if( iFlowCtrl == EIADFlowControlOn && iRxQueueCount == KIADChDataRxLowWaterMark )
+ {
+ SendPnsPepStatusInd( EIADFlowControlOff );
+ //iFlowCtrl = EIADFlowControlOff;// EFalse;
+ }
+ C_TRACE( ( _T( "DLegacyRx::DataMessageDelivered %d %d %d <-" ), iRxQueueCount, KIADChDataRxLowWaterMark, iFlowCtrl ) );
+
+ OstTrace0( TRACE_PIPE, DLEGACYRX_DATAMESSAGEDELIVERED_EXIT, "<DLegacyRx::DataMessageDelivered" );
+ }
+
+void DMultiRx::DataMessageDelivered()
+ {
+ OstTrace0( TRACE_PIPE, DMULTIRX_DATAMESSAGEDELIVERED_ENTRY, ">DMultiRx::DataMessageDelivered" );
+ C_TRACE( ( _T( "DMultiRx::DataMessageDelivered %d ->" ), iThresholdCount ) );
+ ASSERT_DFCTHREAD_INEXT();
+ iThresholdCount++;
+#ifdef _DEBUG
+ TRACE_ASSERT_INFO( iGrantedCreditCount > 0, (TUint8)iSuper.ChannelId()<<KChannelNumberShift ); // used only to verify that anyone does not send us too much data
+ iGrantedCreditCount--;
+#endif
+ if(iThresholdCount == CREDIT_THRESHOLD )
+ {
+ SendCredits( CREDIT_THRESHOLD );
+ iThresholdCount = 0;
+#ifdef _DEBUG
+ iGrantedCreditCount += CREDIT_THRESHOLD; // used only to verify that anyone does not send us too much data
+#endif
+ }
+ C_TRACE( ( _T( "DMultiRx::DataMessageDelivered %d <-" ), iThresholdCount ) );
+ OstTrace0( TRACE_PIPE, DMULTIRX_DATAMESSAGEDELIVERED_EXIT, "<DMultiRx::DataMessageDelivered" );
+ }
+
+TInt DMultiRx::Receive(const TDesC8& aData)
+ {
+ OstTrace1( TRACE_PIPE, DMULTIRX_RECEIVE_ENTRY, ">DMultiRx::Receive;aData=%x", ( TUint )&( aData ) );
+ C_TRACE( ( _T( "DMultiRx::Receive ->" ) ) );
+ iSuper.Receive(aData);
+ return KErrNone;
+ }
+
+TInt DOneRx::Receive(
+ const TDesC8& aData
+ )
+ {
+ OstTrace1( TRACE_PIPE, DONERX_RECEIVE_ENTRY, ">DOneRx::Receive;aData=%x", ( TUint )&( aData ) );
+
+ C_TRACE( ( _T( "DOneRx::Receive ->" ) ) );
+ C_TRACE( ( _T( "DOneRx::DOneRx TBR pipehandle 0x%x" ), iPipeHandle ) ); // TBR
+ iSuper.Receive(aData);
+ C_TRACE( ( _T( "DOneRx::Receive <-" ) ) );
+ return KErrNone;//TODO
+
+ }
+
+TInt DLegacyRx::Receive(
+ const TDesC8& aData
+ )
+ {
+ OstTrace1( TRACE_PIPE, DLEGACYRX_RECEIVE_ENTRY, ">DLegacyRx::Receive;aData=%x", ( TUint )&( aData ) );
+
+ C_TRACE( ( _T( "DLegacyRx::Receive %d %d %d ->" ), iRxQueueCount, KIADChDataRxHighWaterMark, iFlowCtrl ) );
+ iSuper.Receive(aData); // clients receive queue may overflow
+ iRxQueueCount++;
+ if( iRxQueueCount == KIADChDataRxHighWaterMark )
+ {
+ SendPnsPepStatusInd( EIADFlowControlOn );
+// iFlowCtrl = EIADFlowControlOn;//ETrue;//TODO remove iFlowCtrl from DL direction it's for UL
+ }
+ C_TRACE( ( _T( "DLegacyRx::Receive %d %d %d <-" ), iRxQueueCount, KIADChDataRxHighWaterMark, iFlowCtrl ) );
+ OstTraceExt3( TRACE_PIPE, DLEGACYRX_RECEIVE_EXIT, "<DLegacyRx::Receive;iRxQueueCount=%hu;KIADChDataRxHighWaterMark=%hu;iFlowCtrl=%x", iRxQueueCount, KIADChDataRxHighWaterMark, (TUint)(iFlowCtrl) );
+
+ return KErrNone;// TODO: something reasonable here?
+
+ }
+
+void DOneRx::PipeEnabled(
+ // None
+ )
+ {
+ OstTrace0( TRACE_PIPE, DONERX_PIPEENABLED_ENTRY, ">DOneRx::PipeEnabled" );
+
+ C_TRACE( ( _T( "DOneRx::PipeEnabled ->" ) ) );
+ C_TRACE( ( _T( "DOneRx::DOneRx TBR pipehandle 0x%x" ), iPipeHandle ) ); // TBR
+ // TODO: Not send when enabled->enabled
+ SendOneCredit();
+ C_TRACE( ( _T( "DOneRx::PipeEnabled <-" ) ) );
+
+ OstTrace0( TRACE_PIPE, DONERX_PIPEENABLED_EXIT, "<DOneRx::PipeEnabled" );
+ }
+
+void DMultiRx::PipeEnabled(
+ // None
+ )
+ {
+ OstTrace0( TRACE_PIPE, DMULTIRX_PIPEENABLED_ENTRY, ">DMultiRx::PipeEnabled" );
+
+ C_TRACE( ( _T( "DMultiRx::PipeEnabled %d ->" ), iThresholdCount ) );
+ // TODO: Not send when enabled->enabled
+ SendCredits( CREDIT_AMOUNT );
+#ifdef _DEBUG // TODO: WTF why only in debug?
+ iGrantedCreditCount = CREDIT_AMOUNT;
+#endif
+ iThresholdCount = 0;
+ C_TRACE( ( _T( "DMultiRx::PipeEnabled %d <-" ), iThresholdCount ) );
+
+ OstTrace0( TRACE_PIPE, DMULTIRX_PIPEENABLED_EXIT, "<DMultiRx::PipeEnabled" );
+ }
+
+void DLegacyRx::PipeEnabled()
+ {
+ OstTrace0( TRACE_PIPE, DLEGACYRX_PIPEENABLED_ENTRY, ">DLegacyRx::PipeEnabled" );
+ C_TRACE( ( _T( "DLegacyRx::PipeEnabled ->" ) ) );
+ SendPnsPepStatusInd( EIADFlowControlOff ); // Added due to CSD server not sending data without flowcontrol off indication.
+ C_TRACE( ( _T( "DLegacyRx::PipeEnabled <-" ) ) );
+ OstTrace0( TRACE_PIPE, DLEGACYRX_PIPEENABLED_EXIT, "<DLegacyRx::PipeEnabled" );
+ }
+
+
+void DOneRx::PipeDisabled()
+ {
+ OstTrace0( TRACE_PIPE, DONERX_PIPEDISABLED_ENTRY, ">DOneRx::PipeDisabled" );
+ C_TRACE( ( _T( "DOneRx::PipeDisabled ->" ) ) );
+ C_TRACE( ( _T( "DOneRx::DOneRx TBR pipehandle 0x%x" ), iPipeHandle ) ); // TBR
+ C_TRACE( ( _T( "DOneRx::PipeDisabled <-" ) ) );
+ }
+
+void DMultiRx::PipeDisabled()
+ {
+ OstTrace0( TRACE_PIPE, DMULTIRX_PIPEDISABLED_ENTRY, ">DMultiRx::PipeDisabled" );
+ C_TRACE( ( _T( "DMultiRx::PipeDisabled ->" ) ) );
+#ifdef _DEBUG
+ iGrantedCreditCount = 0;
+#endif
+ C_TRACE( ( _T( "DMultiRx::PipeDisabled <-" ) ) );
+ }
+
+void DLegacyRx::PipeDisabled()
+ {
+ OstTrace0( TRACE_PIPE, DLEGACYRX_PIPEDISABLED_ENTRY, ">DLegacyRx::PipeDisabled" );
+ C_TRACE( ( _T( "DLegacyRx::PipeDisabled ->" ) ) );
+ C_TRACE( ( _T( "DLegacyRx::PipeDisabled <-" ) ) );
+ }
+
+void DLegacyRx::SendPnsPepStatusInd(
+ TIADFlowControlStatus aFlowCtrlStatus
+ )
+ {
+ OstTrace1( TRACE_PIPE, DLEGACYRX_SENDPNSPEPSTATUSIND_ENTRY, ">DLegacyRx::SendPnsPepStatusInd;aFlowCtrlStatus=%x", ( TUint )&( aFlowCtrlStatus ) );
+
+ C_TRACE( ( _T( "DLegacyRx::SendPnsPepStatusInd ->" ) ) );
+ TUint8 length( SIZE_PNS_PEP_STATUS_IND + ISI_HEADER_SIZE - PN_HEADER_SIZE );
+ TDes8& tempPtr = iSuper.AllocateDataBlock( SIZE_PNS_PEP_STATUS_IND + ISI_HEADER_SIZE );
+
+ TUint8* msgPtr( const_cast<TUint8*>( tempPtr.Ptr() ) );
+
+ //We start to append from transaction id
+ tempPtr.SetLength( ISI_HEADER_OFFSET_TRANSID );
+
+ msgPtr[ ISI_HEADER_OFFSET_MEDIA ] = PN_MEDIA_SOS;
+ SET_RECEIVER_DEV(msgPtr, OTHER_DEVICE_1);
+ SET_SENDER_DEV(msgPtr, THIS_DEVICE);
+ msgPtr[ ISI_HEADER_OFFSET_RESOURCEID ] = PN_PIPE;
+ SET_LENGTH( msgPtr, length );
+ SET_RECEIVER_OBJ( msgPtr, PN_OBJ_ROUTER );
+ SET_SENDER_OBJ( msgPtr, iSuper.ChannelId() );
+
+ tempPtr.Append( 0x00 ); // transaction id
+ tempPtr.Append( PNS_PEP_STATUS_IND ); // message id
+ tempPtr.Append( iPipeHandle ); // pipe handle
+ tempPtr.Append( PN_PEP_TYPE_COMMON ); // pep type
+ tempPtr.Append( PN_PEP_IND_FLOW_CONTROL );
+ tempPtr.Append( 0x00 ); // reserved
+ tempPtr.Append( 0x00 );
+ if( aFlowCtrlStatus != EIADFlowControlOff )
+ {
+ tempPtr.Append( PEP_IND_BUSY );
+ OstTrace0( TRACE_PIPE, DLEGACYRX_SENDPNSPEPSTATUSIND_BUSY, "DLegacyRx::SendPnsPepStatusInd PEP_IND_BUSY" );
+
+ }
+ else
+ {
+ tempPtr.Append( PEP_IND_READY );
+ OstTrace0( TRACE_PIPE, DLEGACYRX_SENDPNSPEPSTATUSIND_READY, "DLegacyRx::SendPnsPepStatusInd PEP_IND_READY" );
+ }
+ iFlowCtrl = aFlowCtrlStatus;
+ // send to ISA
+ iSuper.Send(tempPtr);
+ C_TRACE( ( _T( "DLegacyRx::SendPnsPepStatusInd <-" ) ) );
+ OstTrace0( TRACE_PIPE, DLEGACYRX_SENDPNSPEPSTATUSIND_EXIT, "<DLegacyRx::SendPnsPepStatusInd" );
+ }
+
+void DOneRx::SendOneCredit(
+ // None
+ )
+ {
+ OstTrace0( TRACE_PIPE, DONERX_SENDONECREDIT_ENTRY, ">DOneRx::SendOneCredit" );
+
+ C_TRACE( ( _T( "DOneRx::SendOneCredit 0x%x ->" ), this ) );
+ C_TRACE( ( _T( "DOneRx::DOneRx TBR pipehandle 0x%x" ), iPipeHandle ) ); // TBR
+
+ TUint8 length( SIZE_PNS_PEP_STATUS_IND + ISI_HEADER_SIZE - PN_HEADER_SIZE );
+ TDes8& tempPtr = iSuper.AllocateDataBlock( SIZE_PNS_PEP_STATUS_IND + ISI_HEADER_SIZE );
+ //We start to append from transaction id
+ tempPtr.SetLength( ISI_HEADER_OFFSET_TRANSID );
+ TUint8* msgPtr( const_cast<TUint8*>( tempPtr.Ptr() ) );
+ msgPtr[ ISI_HEADER_OFFSET_MEDIA ] = PN_MEDIA_SOS;
+ SET_RECEIVER_DEV( msgPtr, OTHER_DEVICE_1);
+ SET_SENDER_DEV( msgPtr, THIS_DEVICE);
+ msgPtr[ ISI_HEADER_OFFSET_RESOURCEID ] = PN_PIPE;
+ SET_LENGTH( msgPtr, length );
+ SET_RECEIVER_OBJ( msgPtr, PN_OBJ_ROUTER );
+ SET_SENDER_OBJ( msgPtr, iSuper.ChannelId() );
+
+ tempPtr.Append( 0x00 ); // transaction id
+ tempPtr.Append( PNS_PEP_STATUS_IND ); // message id
+ tempPtr.Append( iPipeHandle ); // pipe handle
+ tempPtr.Append( PN_PEP_TYPE_COMMON ); // pep type
+ tempPtr.Append( PN_PEP_IND_FLOW_CONTROL ); // Indication ID
+ tempPtr.Append( 0x00 ); // filler
+ tempPtr.Append( 0x00 ); // filler
+ tempPtr.Append( PEP_IND_READY ); // Indication data
+ iSuper.Send(tempPtr);
+ C_TRACE( ( _T( "DOneRx::SendOneCredit <-" ) ) );
+
+ OstTrace0( TRACE_PIPE, DONERX_SENDONECREDIT_EXIT, "<DOneRx::SendOneCredit" );
+ }
+
+void DMultiRx::SendCredits(
+ TUint8 aNum // TODO : const
+ )
+ {
+ OstTraceExt1( TRACE_PIPE, DMULTIRX_SENDCREDITS_ENTRY, ">DMultiRx::SendCredits;aNum=%hhu", aNum );
+
+ C_TRACE( ( _T( "DMultiRx::SendCredits %d ->" ), aNum ) );
+ TUint8 length( SIZE_PNS_PEP_STATUS_IND + ISI_HEADER_SIZE - PN_HEADER_SIZE );
+ TDes8& tempPtr = iSuper.AllocateDataBlock( SIZE_PNS_PEP_STATUS_IND + ISI_HEADER_SIZE );
+ //We start to append from transaction id
+ tempPtr.SetLength( ISI_HEADER_OFFSET_TRANSID );
+ TUint8* msgPtr( const_cast<TUint8*>( tempPtr.Ptr() ) );
+ msgPtr[ ISI_HEADER_OFFSET_MEDIA ] = PN_MEDIA_SOS;
+ SET_RECEIVER_DEV( msgPtr, OTHER_DEVICE_1);
+ SET_SENDER_DEV( msgPtr, THIS_DEVICE);
+ msgPtr[ ISI_HEADER_OFFSET_RESOURCEID ] = PN_PIPE;
+ SET_LENGTH( msgPtr, length );
+ SET_RECEIVER_OBJ( msgPtr, PN_OBJ_ROUTER );
+ SET_SENDER_OBJ( msgPtr, iSuper.ChannelId() );
+
+ tempPtr.Append( 0x00 ); // transaction id
+ tempPtr.Append( PNS_PEP_STATUS_IND ); // message id
+ tempPtr.Append( iPipeHandle ); // pipe handle
+ tempPtr.Append( PN_PEP_TYPE_COMMON ); // pep type
+ tempPtr.Append( PN_PEP_IND_MCFC_GRANT_CREDITS ); // indication id in MULTI must
+ tempPtr.Append( 0x00 ); // filler
+ tempPtr.Append( 0x00 ); // filler
+ tempPtr.Append( aNum ); // MCBFC granted credits.
+ iSuper.Send(tempPtr);
+ C_TRACE( ( _T( "DMultiRx::SendCredits %d <-" ), aNum ) );
+
+ OstTrace0( TRACE_PIPE, DMULTIRX_SENDCREDITS_EXIT, "<DMultiRx::SendCredits" );
+ }
+
+// ********************* HOX! ***********************
+// Here we assume that block is reserved using AllocateDataBlock!!! == there is 12 bytes in front
+
+// HOX HOX: AllocateDataBlock done and it set's most of the information. senderobj and handle left for pep.
+
+void DPepTransceiver::FillIsiHeader(
+ TDes8& aData
+ )
+ {
+ OstTrace1( TRACE_PIPE, DPEPTRANSCEIVER_FILLISIHEADER_ENTRY, ">DPepTransceiver::FillIsiHeader;aData=%x", ( TUint )&( aData ) );
+
+ C_TRACE( ( _T( "DPepTransceiver::FillIsiHeader ->" ) ) );
+ TUint8* msgPtr( const_cast<TUint8*>( aData.Ptr() ) );
+ SET_SENDER_OBJ( msgPtr, iChannelId );
+ //Assumption is only for data!
+ ASSERT_RESET_ALWAYS( msgPtr[ ISI_HEADER_OFFSET_MESSAGEID ] == PNS_PIPE_DATA, EIADNotSupported | EIADFaultIdentifier3 << KFaultIdentifierShift | (TUint8)ChannelId()<<KChannelNumberShift );
+ msgPtr[ ISI_HEADER_OFFSET_TRANSID ] = 0x00;
+ msgPtr[ ISI_HEADER_SIZE + PNS_PIPE_DATA_OFFSET_PIPEHANDLE ] = iPipeHandle;
+ ASSERT_RESET_ALWAYS( aData.Length() > ( ISI_HEADER_SIZE + PNS_PIPE_DATA_OFFSET_PIPEHANDLE ), EIADOverTheLimits | EIADFaultIdentifier25 << KFaultIdentifierShift );
+
+ C_TRACE( ( _T( "DPepTransceiver::FillIsiHeader <-" ) ) );
+
+ OstTrace0( TRACE_PIPE, DPEPTRANSCEIVER_FILLISIHEADER_EXIT, "<DPepTransceiver::FillIsiHeader" );
+ }
+
+TInt DOneTx::Send(
+ TDes8& aData
+ )
+ {
+ OstTrace1( TRACE_PIPE, DONETX_SEND_ENTRY, ">DOneTx::Send;aData=%x", ( TUint )&( aData ) );
+
+ C_TRACE( ( _T( "DOneTx::Send ->" ) ) );
+ TInt retVal(KErrNone);
+ if( iFlowCtrl == EIADFlowControlOff )
+ {
+ iSuper.FillIsiHeader( aData );
+ retVal = iSuper.Send( aData );
+ SetFlowCtrl( EIADFlowControlOn );
+ //iSuper.SetFlowCtrl( EIADFlowControlOn );
+ }
+ else
+ {
+ TRACE_ASSERT_INFO( 0, (TUint8)iSuper.ChannelId()<<KChannelNumberShift );
+ Kern::Printf("IAD: iChannelId = %d", iSuper.ChannelId() );
+ retVal = KErrOverflow;
+ }
+ C_TRACE( ( _T( "DOneTx::Send 0x%x <-" ), retVal ) );
+
+ OstTrace1( TRACE_PIPE, DONETX_SEND_EXIT, "<DOneTx::Send;retVal=%d", retVal );
+ return retVal;
+ }
+
+TInt DMultiTx::Send(
+ TDes8& aData
+ )
+ {
+ OstTrace1( TRACE_PIPE, DMULTITX_SEND_ENTRY, ">DMultiTx::Send;aData=%x", ( TUint )&( aData ) );
+
+ C_TRACE( ( _T( "DMultiTx::Send %d ->" ), iGrantedCredits ) );
+ TInt retVal( KErrNone );
+ if( iFlowCtrl == EIADFlowControlOff )
+ {
+ iSuper.FillIsiHeader( aData );
+ retVal = iSuper.Send( aData );
+ iGrantedCredits--;
+ if( iGrantedCredits == 0 )
+ {
+ SetFlowCtrl( EIADFlowControlOn );
+ //iSuper.SetFlowCtrl( EIADFlowControlOn );
+ }
+ }
+ else
+ {
+ TRACE_ASSERT_ALWAYS;
+ Kern::Printf("IAD: iChannelId = %d", iSuper.ChannelId() );
+ retVal = KErrOverflow;
+ }
+ C_TRACE( ( _T( "DMultiTx::Send %d %d <-" ), iGrantedCredits, retVal ) );
+
+ OstTrace1( TRACE_PIPE, DMULTITX_SEND_EXIT, "<DMultiTx::Send;retVal=%d", retVal );
+ return retVal;
+ }
+
+TInt DLegacyTx::Send(TDes8& aData)
+ {
+ OstTrace1( TRACE_PIPE, DLEGACYTX_SEND_ENTRY, ">DLegacyTx::Send;aData=%x", ( TUint )&( aData ) );
+ C_TRACE( ( _T( "DLegacyTx::Send ->" ) ) );
+ TInt retVal( KErrNone );
+ if( iFlowCtrl == EIADFlowControlOff )
+ {
+ iSuper.FillIsiHeader( aData );
+ retVal = iSuper.Send( aData );
+ }
+ else
+ {
+ TRACE_ASSERT_INFO( 0, (TUint8)iSuper.ChannelId()<<KChannelNumberShift );
+ Kern::Printf("IAD: iChannelId = %d", iSuper.ChannelId() );
+ retVal = KErrOverflow;
+ }
+ C_TRACE( ( _T( "DLegacyTx::Send return 0x%x <-" ), retVal ) );
+
+ OstTrace1( TRACE_PIPE, DLEGACYTX_SEND_EXIT, "<DLegacyTx::Send;retVal=%d", retVal );
+ return retVal;
+ }