DISIKernelChannel::~DISIKernelChannel(
// None
)
{
C_TRACE( ( _T( "DISIKernelChannel::~DISIKernelChannel 0x%x 0x%x>" ), this ) );
// Send channel destroyed message to complete with EFalse.
TThreadMessage& m=Kern::Message();
m.iValue = KDestroyChannelMsg;
m.SendReceive( &iKernelChMsgQue );
C_TRACE( ( _T( "DISIKernelChannel::~DISIKernelChannel iRx 0x%x" ), iRx ) );
// Only modified in constructor, if not created already reseted.
delete iRx;
iRx = NULL;
C_TRACE( ( _T( "DISIKernelChannel::~DISIKernelChannel iEmptyRxDfc 0x%x" ), iEmptyRxDfc ) );
// Only modified in constructor, if not created already reseted.
if ( iEmptyRxDfc )
{
iEmptyRxDfc->Cancel();
delete iEmptyRxDfc;
iEmptyRxDfc = NULL;
}
C_TRACE( ( _T( "DISIKernelChannel::~DISIKernelChannel iRequests 0x%x" ), iEmptyRxDfc ) );
iPtrPtrToRxBuf = NULL;
iRouterIf = NULL;
// Only modified in constructor, if not created already reseted.
delete iRequests;
iRequests = NULL;
C_TRACE( ( _T( "DISIKernelChannel::~DISIKernelChannel 0x%x 0x%x<" ), this ) );
}
// -----------------------------------------------------------------------------
// DIscDevice::Flush
// Dfc to empty control channel and other send queues
// ( other items were commented in a header ).
// -----------------------------------------------------------------------------
//
void DIscDevice::Flush( TAny* aPtr )
{
C_TRACE( ( _T( "DIscDevice::Flush(0x%x)" ), aPtr ) );
DIscDevice* device = ( DIscDevice* )aPtr;
TDes8* frame = NULL;
TIscSendFrameInfo* temp = NULL;
TInt irqLevel(0);
// If transmission is asynchronous and there can't be
// several requests at the same time
if ( !iIscDataTransmissionInterface->IsWritePending() )
{
irqLevel = DisableIrqs();
if ( !iControlSendQueue->Empty() )
{
temp = iControlSendQueue->GetFirstFrameInfo();
frame = ( TDes8* )iControlSendQueue->RemoveFirst();
}
else
{
temp = iSendQueue->GetFirstFrameInfo();
frame = ( TDes8* )iSendQueue->RemoveFirst();
}
RestoreIrqs( irqLevel );
C_TRACE( ( _T( "DIscDevice::Flush after RESTOREIRQS" ) ) );
if ( frame )
iIscDataTransmissionInterface->SendFrame( *frame, device->iSendDfc, temp->iFrameInfo );
}
C_TRACE( ( _T( "DIscDevice::Flush - return 0x0" ) ) );
}
TInt DISIRouter::Send(
TDes8& aMessage,
const TUint8 aObjId
)
{
C_TRACE( ( _T( "DISIRouter::Send 0x%x 0x%x>" ), &aMessage, aObjId ) );
if( ( ( aObjId == EIscNokiaUsbPhonetLink ) && ( GET_SENDER_DEV( aMessage.Ptr() ) == PN_DEV_PC ) ) ||
( aObjId == PN_OBJ_ROUTING_REQ ) ||
( aObjId == PN_OBJ_EVENT_MULTICAST ) ||
( aObjId == ROUTER_OBJECT_IDENTIFIER ) ||
( aObjId == PIPEHANDLER_OBJECT_IDENTIFIER ) )
{
// No need to update sender dev and obj id
C_TRACE( ( _T( "DISIRouter::Send message tx address not needed to updata 0x%x 0x%x>" ), aObjId, GET_SENDER_DEV( aMessage.Ptr() ) ) );
}
else
{
TUint8* messageBlockPtr( const_cast<TUint8*>( aMessage.Ptr() ) );
SET_SENDER_DEV( messageBlockPtr, PN_DEV_OWN );
SET_SENDER_OBJ( messageBlockPtr, aObjId );
}
TInt error = iShCLTransceiver->RouteISIMessage( aMessage );
C_TRACE( ( _T( "DISIRouter::Send 0x%x 0x%x<" ), &aMessage, aObjId ) );
return error;
}
void DISIKernelChannel::DoCancel(
TInt aRequest,
TInt aMask )
{
C_TRACE( ( _T( "DISIKernelChannel::DoCancel 0x%x 0x%x>" ), this, iObjId ) );
ASSERT_RESET_ALWAYS( EISILastAsyncRequest > ( aMask&aRequest ), EISIKernelChannelOverTheLimits | EDISIKernelChannelId << KClassIdentifierShift );
if( iRequests->IsPending( aMask&aRequest ) )
{
switch( aMask&aRequest )
{
case EISIAsyncReceive:
{
C_TRACE( ( _T( "DISIKernelChannel::DoCancel EIADAsyncReceive 0x%x ptrs 0x%x 0x%x" ), this, iPtrPtrToRxBuf, &iPtrPtrToRxBuf ) );
iPtrPtrToRxBuf = NULL;
break;
}
default:
{
ASSERT_RESET_ALWAYS( 0, EISIKernelChannelWrongRequest | EDISIKernelChannelId << KClassIdentifierShift );
break;
}
}
EnqueChannelRequestCompleteDfc( aMask&aRequest, KErrCancel );
}
else
{
C_TRACE( ( _T( "DISIKernelChannel::DoCancel nothing to cancel 0x%x" ), this ) );
}
C_TRACE( ( _T( "DISIKernelChannel::DoCancel 0x%x 0x%x<" ), this, iObjId ) );
}
DISIRouter::~DISIRouter(
// None
)
{
C_TRACE( ( _T( "DISIRouter::~DISIRouter>" ) ) );
iSelfPtr = NULL;
for( TUint8 i( 0 ); i < iStaticObjIdTable.Count(); i++)
{
delete iStaticObjIdTable[ i ];
iStaticObjIdTable[ i ] = NULL;
}
iStaticObjIdTable.Reset();
for( TInt i( 0 ); i <= KMaxAmountOfObjId; i++)
{
if( iClientTable[ i ] )
{
delete iClientTable[ i ];
iClientTable[ i ] = NULL;
}
}
// All must exist otherways reseted.
delete iInitializeDfc;
iInitializeDfc = NULL;
delete iShClientThreadContainer;
iShClientThreadContainer = NULL;
delete iShCLTransceiver;
iShCLTransceiver = NULL;
delete iClientTableFastMutex;
iClientTableFastMutex = NULL;
C_TRACE( ( _T( "DISIRouter::~DISIRouter<" ) ) );
}
// KErrBadDescriptor, if message length too small
// KErrUnderFlow, if message length too big.
// KErrCouldNotConnect, if receiver object is out of scope.
TInt DISICLTransceiver::ValidateISIMessage(
TDes8& aMessage
)
{
C_TRACE( ( _T( "DISICLTransceiver::ValidateISIMessage 0x%x>" ), &aMessage ) );
const TUint16 descLength( aMessage.Length() );
TInt msgOk( KErrNone );
msgOk = ( ISI_HEADER_OFFSET_MESSAGEID >= descLength ) ? KErrBadDescriptor : msgOk;
TRACE_ASSERT_INFO( msgOk == KErrNone, msgOk );
// Get ISI message length after known that the descriptor is big enough.
const TUint8* msgPtr( aMessage.Ptr() );
const TUint16 isiMsgLength( GET_LENGTH( msgPtr ) + PN_HEADER_SIZE );
// If the descriptor length is less than ISI message length.
msgOk = ( ( msgOk == KErrNone && isiMsgLength > descLength ) ? KErrUnderflow : msgOk );
TRACE_ASSERT_INFO( msgOk == KErrNone, msgOk );
// If the ISI message length is bigger that the largest supported.
msgOk = ( ( msgOk == KErrNone && isiMsgLength > KMaxISIMsgSize ) ? KErrUnderflow : msgOk );
TRACE_ASSERT_INFO( msgOk == KErrNone, msgOk );
// If the ISI message length with PN_HEADER_SIZE is less or equal than ISI_HEADER_OFFSET_MESSAGEID.
msgOk = ( ( msgOk == KErrNone && isiMsgLength <= ISI_HEADER_OFFSET_MESSAGEID ) ? KErrUnderflow : msgOk );
TRACE_ASSERT_INFO( msgOk == KErrNone, msgOk );
TRACE_ASSERT_INFO( msgOk == KErrNone, isiMsgLength );
TRACE_ASSERT_INFO( msgOk == KErrNone, descLength );
C_TRACE( ( _T( "DISICLTransceiver::ValidateISIMessage %d<" ), msgOk ) );
return msgOk;
}
// -----------------------------------------------------------------------------
// DIscDevice::QueueFrame
// Queue frames that will be sent to Domestic OS
// ( other items were commented in a header ).
// -----------------------------------------------------------------------------
//
EXPORT_C TInt DIscDevice::QueueFrame(
const TUint16 aChannelId,
const TDesC8* aFrame,
const TAny* aChannelPtr,
TAny* aFrameInfo )
{
C_TRACE( ( _T( "DIscDevice::QueueFrame(0x%x, 0x%x, 0x%x, 0x%x)" ), aChannelId, aFrame, aChannelPtr, aFrameInfo ) );
TInt error = KErrNone;
// control channel frame ( highest priority )
if ( aChannelId == KIscControlChannel )
{
C_TRACE( ( _T( "DIscDevice::QueueFrame control frame queue" ) ) );
//add to control frame queue
error = iControlSendQueue->Add( ( TDes8* )aFrame, aChannelId, ( DIscChannel* )aChannelPtr, aFrameInfo );
}
else
{
C_TRACE( ( _T( "DIscDevice::QueueFrame send queue" ) ) );
// add to send queue
error = iSendQueue->Add( ( TDes8* )aFrame, aChannelId, ( DIscChannel* )aChannelPtr, aFrameInfo );
}
C_TRACE( ( _T( "DIscDevice::QueueFrame - return 0x%x" ), error ) );
return error;
}
void DISICLTransceiver::UpdateDynamicDeviceTable( const TUint8 aDynamicDevId, const TUint8 aStaticDevId )
{
C_TRACE( ( _T( "DISICLTransceiver::UpdateDynamicDeviceTable 0x%x 0x%x>" ), aDynamicDevId, aStaticDevId) );
TBool deviceExist(EFalse);
TInt count(iDynamicDeviceTable.Count());
TInt err( Kern::MutexWait( *iDynamicDeviceTableMutex ) );
ASSERT_RESET_ALWAYS( ( err == KErrNone ), ( EISICLTransceiverMutexWaitFailed2 | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
for( TUint8 i = 0; i < count; i++ )
{
C_TRACE( ( _T( "DISICLTransceiver::UpdateDynamicDeviceTable find dynamic device %d" ), i) );
if( iDynamicDeviceTable[ i ]->iDynamicDevId == aDynamicDevId )
{
C_TRACE( ( _T( "DISICLTransceiver::UpdateDynamicDeviceTable dyn dev exist i = %d aDynamicDevId 0x%x staticDevId 0x%x previous 0x%x" ), i, iDynamicDeviceTable[ i ]->iDynamicDevId, aStaticDevId, iDynamicDeviceTable[ i ]->iStaticDevId ) );
iDynamicDeviceTable[ i ]->iStaticDevId = aStaticDevId;
deviceExist = ETrue;
break;
}
}
if ( !deviceExist )
{
C_TRACE( ( _T( "DISICLTransceiver::UpdateDynamicDeviceTable new dynamic device added 0x%x 0x%x" ), aDynamicDevId, aStaticDevId ) );
iDynamicDeviceTable.Append( new TDynamicDevice( aDynamicDevId, aStaticDevId ) );
}
Kern::MutexSignal( *iDynamicDeviceTableMutex );
C_TRACE( ( _T( "DISICLTransceiver::UpdateDynamicDeviceTable 0x%x 0x%x<" ), aDynamicDevId, aStaticDevId) );
}
void DISICLTransceiver::GetDeviceConnectionStates(
RArray<TUint8>& aDeviceIdentifierList,
const TBool aConnectedDevice
)
{
C_TRACE( ( _T( "DISICLTransceiver::GetDeviceConnectionStates 0x%x 0x%x>" ), &aDeviceIdentifierList, aConnectedDevice ) );
const TInt count( iShDevices.Count() );
for( TInt index( 0 ); index < count; index++ )
{
DISIDevice* tmpDevice = iShDevices[ index ];
ASSERT_RESET_ALWAYS( tmpDevice, ( EISICLTransceiverNULLPtr3 | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
tmpDevice->LockDeviceFM();
if( tmpDevice->GetDeviceState() == aConnectedDevice )
{
const TUint8 deviceIdentifier( tmpDevice->GetDeviceIdentifier() );
tmpDevice->FreeDeviceFM();
aDeviceIdentifierList.Append( deviceIdentifier );
}
else
{
tmpDevice->FreeDeviceFM();
}
}
C_TRACE( ( _T( "DISICLTransceiver::GetDeviceConnectionStates 0x%x 0x%x<" ), &aDeviceIdentifierList, aConnectedDevice ) );
}
TBool DISIRouter::Receive( TDes8& aMessage, const TUint8 aObjId )
{
C_TRACE( ( _T( "DISIRouter::Receive 0x%x 0x%x>" ), &aMessage, aObjId ) );
TBool error( EFalse );
TUint8* messageBlockPtr( const_cast<TUint8*>( aMessage.Ptr() ) );
NKern::FMWait( iClientTableFastMutex );
if( iClientTable[ aObjId ] )
{
NKern::FMSignal( iClientTableFastMutex );
( iClientTable[ aObjId ]->iChannel )->Receive( aMessage ); //may not be safe, consider receive/delete sync
C_TRACE( ( _T( "DISIRouter::Receive ok 0x%x 0x%x" ), &aMessage, aObjId ) );
error = ETrue;
}
else
{
NKern::FMSignal( iClientTableFastMutex );
C_TRACE( ( _T( "DISIRouter::Receive failed 0x%x 0x%x" ), &aMessage, aObjId ) );
error = EFalse;
}
C_TRACE( ( _T( "DISIRouter::Receive 0x%x 0x%x %d<" ), &aMessage, aObjId, error ) );
return error;
}
TInt DISICLTransceiver::SendCommIsaEntityNotReachableResp(
TDes8& aNotDeliveredMessage
)
{
C_TRACE( ( _T( "DISICLTransceiver::SendCommIsaEntityNotReachableResp 0x%x>" ), &aNotDeliveredMessage ) );
const TUint8* notDeliveredMsgPtr( aNotDeliveredMessage.Ptr() );
TInt error = KErrAlreadyExists;
// Avoid COMM_ISA_ENTITY_NOT_REACHABLE_RESP loop.
if( ( notDeliveredMsgPtr[ ISI_HEADER_OFFSET_MESSAGEID ] == COMMON_MESSAGE ) &&
( ( notDeliveredMsgPtr[ ISI_HEADER_OFFSET_SUBMESSAGEID ] == COMM_ISA_ENTITY_NOT_REACHABLE_RESP ) ||
( notDeliveredMsgPtr[ ISI_HEADER_OFFSET_SUBMESSAGEID ] == COMM_SERVICE_NOT_IDENTIFIED_RESP ) ) )
{
C_TRACE( ( _T( "DISICLTransceiver Not sending another CommIsaEntityNotReachableResp 0x%x 0x%x" ), &aNotDeliveredMessage, notDeliveredMsgPtr[ ISI_HEADER_OFFSET_SUBMESSAGEID ] ) );
}
else
{
// Follows COMM specification: 000.031
TUint8 length( ISI_HEADER_SIZE + SIZE_COMMON_MESSAGE_COMM_ISA_ENTITY_NOT_REACHABLE_RESP );
TDes8& respMsg = MemApi::AllocBlock( length );
ASSERT_RESET_ALWAYS( length > ISI_HEADER_OFFSET_MESSAGEID, ( EISICLTransceiverOverTheLimits | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
TUint8* respMsgPtr = const_cast<TUint8*>( respMsg.Ptr() );
// We start to append from transaction id.
respMsg.SetLength( ISI_HEADER_OFFSET_TRANSID );
// Get the header until messageid from prev. message.
// Just turn receiver and sender device and object vice versa.
respMsgPtr[ ISI_HEADER_OFFSET_MEDIA ] = notDeliveredMsgPtr[ ISI_HEADER_OFFSET_MEDIA ];
SET_RECEIVER_DEV( respMsgPtr, GET_SENDER_DEV( aNotDeliveredMessage ) );
SET_SENDER_DEV ( respMsgPtr, GET_RECEIVER_DEV( aNotDeliveredMessage ) );
respMsgPtr[ ISI_HEADER_OFFSET_RESOURCEID ] = notDeliveredMsgPtr[ ISI_HEADER_OFFSET_RESOURCEID ];
SET_LENGTH( respMsgPtr, ( length - PN_HEADER_SIZE ) );
SET_RECEIVER_OBJ( respMsgPtr, GET_SENDER_OBJ( aNotDeliveredMessage ) );
SET_SENDER_OBJ( respMsgPtr, GET_RECEIVER_OBJ( aNotDeliveredMessage ) );
// Set from undelivered message
respMsg.Append( notDeliveredMsgPtr[ ISI_HEADER_OFFSET_TRANSID ] );
// Message Identifier
respMsg.Append( COMMON_MESSAGE );
// Sub message Identifier.
respMsg.Append( COMM_ISA_ENTITY_NOT_REACHABLE_RESP );
// Not Delivered Message from original message.
respMsg.Append( notDeliveredMsgPtr[ ISI_HEADER_OFFSET_MESSAGEID ] );
// Status
respMsg.Append( COMM_ISA_ENTITY_NOT_AVAILABLE );// different status in a case of device not existing
// Filler
const TUint8 KFiller( 0x00 );
respMsg.Append( KFiller );
// Filler
respMsg.Append( KFiller );
// Filler
respMsg.Append( KFiller );
error = RouteISIMessage( respMsg, EFalse );
// Programming error in this function if below assert is raised
ASSERT_RESET_ALWAYS( KErrNone == error, ( EISICLTransceiverCommIsaEntityNotReachableResp | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
}
MemApi::DeallocBlock( aNotDeliveredMessage );
C_TRACE( ( _T( "DISICLTransceiver::SendCommIsaEntityNotReachableResp 0x%x<" ), &aNotDeliveredMessage ) );
return error;
}
void DISIRouter::InitializeDfc(
TAny* aPtr
)
{
C_TRACE( ( _T( "DISIRouter::InitializeDfc>" ) ) );
DISIRouter* self = reinterpret_cast<DISIRouter*>( aPtr );
self->Initialize();
C_TRACE( ( _T( "DISIRouter::InitializeDfc<" ) ) );
}
void DISIKernelChannel::MsgQDfc(
TAny* aPtr
)
{
C_TRACE( ( _T( "DISIKernelChannel::MsgQDfc>" ) ) );
DISIKernelChannel* tmp = reinterpret_cast<DISIKernelChannel*>( aPtr );
tmp->HandleThreadMsg( static_cast<TThreadMessage&>(*tmp->iKernelChMsgQue.iMessage ) );
C_TRACE( ( _T( "DISIKernelChannel::MsgQDfc<" ) ) );
}
// -----------------------------------------------------------------------------
// CUsbPnServer::CUsbPnServer
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CUsbPnServer::CUsbPnServer()
:CServer2(CActive::EPriorityStandard)
,iSessionCount(0)
{
OstTrace0( TRACE_NORMAL, CUSBPNSERVER_CUSBPNSERVER_ENTRY, "CUsbPnServer::CUsbPnServer" );
C_TRACE( ( _T( "CUsbPnServer::CUsbPnServer()" ) ) );
OstTrace0( TRACE_NORMAL, CUSBPNSERVER_CUSBPNSERVER_EXIT, "CUsbPnServer::CUsbPnServer - return" );
C_TRACE( ( _T( "CUsbPnServer::CUsbPnServer() - return" ) ) );
}
DISIKernelChannel::DISIKernelAsyncRequests::DISIKernelAsyncRequests(
const TInt aSize
)
{
C_TRACE( ( _T( "DISIKernelAsyncRequests::DISIKernelAsyncRequests size %d>" ), aSize ) );
iRequestLock = new NFastMutex();
iDfcFunctionList = new TDfc*[ aSize ];
iRequestStatusList = new TRequestStatus*[ aSize ];
C_TRACE( ( _T( "DISIKernelAsyncRequests::DISIKernelAsyncRequests<" ) ) );
}
DISICLTransceiver::DISIDevice::~DISIDevice()
{
C_TRACE( ( _T( "DISICLTransceiver::DISIDevice::~DISIDevice>" ) ) );
iShLink->Release();
iShLink = NULL;
// If not exists faulted already.
delete iShDeviceMutex;
iShDeviceMutex = NULL;
C_TRACE( ( _T( "DISICLTransceiver::DISIDevice::~DISIDevice<" ) ) );
}
void DISICLTransceiver::StateChangedDfc(
TAny* aPtr
)
{
C_TRACE( ( _T( "DISICLTransceiver::StateChangedDfc>" ) ) );
DISICLTransceiver* self = reinterpret_cast<DISICLTransceiver*>( aPtr );
ASSERT_RESET_ALWAYS( self, ( EISICLTransceiverNULLPtr5 | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
self->ReadStateChanges();
C_TRACE( ( _T( "DISICLTransceiver::StateChangedDfc<" ) ) );
}
DISIKernelChannel::DISIKernelAsyncRequests::~DISIKernelAsyncRequests()
{
C_TRACE( ( _T( "DISIKernelAsyncRequests::~DISIKernelAsyncRequests>" ) ) );
// Delete space reserved for the array not the contents of the array, so mem behind pointers that are not owned are not deleted.
delete iDfcFunctionList;
delete iRequestStatusList;
// Deletes lock
delete iRequestLock;
C_TRACE( ( _T( "DISIKernelAsyncRequests::~DISIKernelAsyncRequests<" ) ) );
}
// Called in 1...N transceivers thread context
void DISIKernelChannel::Receive(
const TDesC8& aMessage
)
{
C_TRACE( ( _T( "DISIKernelChannel::Receive 0x%x 0x%x 0x%x>" ), this, &aMessage, iObjId ) );
ASSERT_THREAD_CONTEXT_ALWAYS( ( EISIKernelChannelNotThreadContext1 | EDISIKernelChannelId << KClassIdentifierShift ) );
iRx->Add( aMessage );
iEmptyRxDfc->Enque();
C_TRACE( ( _T( "DISIKernelChannel::Receive 0x%x 0x%x 0x%x<" ), this, &aMessage, iObjId ) );
}
// Called only in router extension thread context.
void DISIKernelChannel::EnqueChannelRequestCompleteDfc(
TInt aRequest,
TInt aStatusToComplete
)
{
C_TRACE( ( _T( "DISIKernelChannel::EnqueChannelRequestCompleteDfc 0x%x %d %d 0x%x 0x%x>" ), this, aRequest, aStatusToComplete, iObjId ) );
ASSERT_THREAD_CONTEXT_ALWAYS( ( EISIKernelChannelNotThreadContext2 | EDISIKernelChannelId << KClassIdentifierShift ) );
iRequests->Complete( aRequest, aStatusToComplete );
C_TRACE( ( _T( "DISIKernelChannel::EnqueChannelRequestCompleteDfc 0x%x %d %d 0x%x 0x%x<" ), this, aRequest, aStatusToComplete, iObjId ) );
}
// -----------------------------------------------------------------------------
// CUsbPnServer::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CUsbPnServer::ConstructL()
{
OstTrace0( TRACE_NORMAL, CUSBPNSERVER_CONSTRUCTL_ENTRY, "CUsbPnServer::ConstructL" );
C_TRACE( ( _T( "CUsbPnServer::ConstructL()" ) ) );
StartL( KUsbPnServerName );
iInterface = CUsbPnInterface::NewL();
OstTrace0( TRACE_NORMAL, CUSBPNSERVER_CONSTRUCTL_EXIT, "CUsbPnServer::ConstructL - return void" );
C_TRACE( ( _T( "CUsbPnServer::ConstructL() - return void" ) ) );
}
// This is called in 1...N thread contextes
void DISICLTransceiver::ReceiveISIMessage(
const TDesC8& aMessage,
const TUint8 aTrxId
)
{
C_TRACE( ( _T( "DISICLTransceiver::ReceiveMsg 0x%x 0x%x 0x%x>" ), this, &aMessage, aTrxId ) );
// Can only be called from thread context.
ASSERT_THREAD_CONTEXT_ALWAYS( ( EISICLTransceiverNotThreadContext | EDISIUserChannelTraceId << KClassIdentifierShift ) );
TUint8 txDevId = GET_SENDER_DEV( aMessage.Ptr() );
if ( DynamicDevice( txDevId ) )
{
TUint8 staticDevId(0);
const TInt count( iShDevices.Count() );
TInt index(0);
TBool staticDeviceFound(EFalse);
MISIRouterLinkIf* Link = NULL;
while( !staticDeviceFound && ( index < count ) )
{
C_TRACE( ( _T( "DISICLTransceiver::ReceiveMsg find static device for trx 0x%x index %d" ), aTrxId, index ) );
DISIDevice* tmpDevice = iShDevices[ index ];
ASSERT_RESET_ALWAYS( tmpDevice, ( EISICLTransceiverNULLPtr4 | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
tmpDevice->LockDeviceFM();
Link = tmpDevice->GetLink();
if( Link->GetTrxId() == aTrxId )
{
staticDevId = tmpDevice->GetDeviceIdentifier();
tmpDevice->FreeDeviceFM();
C_TRACE( ( _T( "DISICLTransceiver::ReceiveMsg static device 0x%x trx 0x%x" ), this, &aMessage, aTrxId ) );
staticDeviceFound = ETrue;
}
else
{
tmpDevice->FreeDeviceFM();
}
index++;
}
#ifdef USE_MEDIAAPI
if ( PN_DEV_PC == GET_SENDER_DEV( aMessage.Ptr() ))
{
C_TRACE( ( _T( "DISICLTransceiver::ReceiveMsg 0x%x 0x%x trx id = %d<" ), this, &aMessage, (Link->GetTrxId()) ) );
iDevPcLastActiveTrxId = iDevPcLastSendTrxId;
iDevPcLastSendTrxId = Link->GetTrxId();
}
#endif /* USE_MEDIAAPI */
UpdateDynamicDeviceTable( txDevId, staticDevId );
}
// else static device. No need to save trxId
iRxQueue->Add( aMessage );
iRxQueueDfc->Enque();
C_TRACE( ( _T( "DISICLTransceiver::ReceiveMsg 0x%x 0x%x 0x%x<" ), this, &aMessage, aTrxId ) );
}
// -----------------------------------------------------------------------------
// CUsbPnServer::SessionOpened
// ?implementation_description
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CUsbPnServer::SessionOpened()
{
OstTrace0( TRACE_NORMAL, CUSBPNSERVER_SESSIONOPENED_ENTRY, "CUsbPnServer::SessionOpened" );
C_TRACE( ( _T( "CUsbPnServer::SessionOpened()" ) ) );
iSessionCount++;
OstTrace1( TRACE_NORMAL, CUSBPNSERVER_SESSIONOPENED, "CUsbPnServer::SessionOpened - session count = 0x%x", iSessionCount );
C_TRACE( ( _T( "CUsbPnServer::SessionOpened() - session count = 0x%x" ), iSessionCount ) );
OstTrace0( TRACE_NORMAL, CUSBPNSERVER_SESSIONOPENED_EXIT, "CUsbPnServer::SessionOpened - return void" );
C_TRACE( ( _T( "CUsbPnServer::SessionOpened() - return void" ) ) );
}
DECLARE_STANDARD_EXTENSION()
{
Kern::Printf( "ISA Access Extension" );
C_TRACE( ( _T( "DIsaAccessExtension EntryPoint ->" ) ) );
// Create a container extension
DIsaAccessExtension* extension = new DIsaAccessExtension();
TRACE_ASSERT( extension );
C_TRACE( ( _T( "DIsaAccessExtension EntryPoint <-" ) ) );
return extension ? KErrNone : KErrNoMemory;
}
void DISIRouter::Initialize(
// None
)
{
C_TRACE( ( _T( "DISIRouter::Initialize> this: 0x%x" ), this ) );
iSelfPtr = this;
iClientTableFastMutex = new NFastMutex();
ASSERT_RESET_ALWAYS( iClientTableFastMutex, ( EISIRouterNULLPtr2 | EDISIRouterTraceId << KClassIdentifierShift ) );
for( TInt i( 0 ); i < KMaxAmountOfObjId; i++)
{
iClientTable[ i ] = NULL;
}
// comment improve hex or des
// nameservice, communication manager, routerservice...
// UID ObjId
iStaticObjIdTable.Append( new TStaticId( 123, 0x70 ) ); // for testing ISI API
iStaticObjIdTable.Append( new TStaticId( 200, 0x71 ) ); // for testing ISI API
iStaticObjIdTable.Append( new TStaticId( 201, 0x72 ) ); // for testing ISI API
iStaticObjIdTable.Append( new TStaticId( 202, 0x73 ) ); // for testing ISI API
//
#ifndef WITHOUT_WRAPPERS_IN_USE
// Map all the kernel channels as they used to be
for( TInt id( KFirstUserChannel ); id < KLastKernelChannel; id++ )
{
if ( ( id != KNotInitializedId ) &&
( id != PN_OBJ_EVENT_MULTICAST ) &&
( id != PN_OBJ_EVENT_MULTICAST ) &&
( id != ROUTER_OBJECT_IDENTIFIER ) &&
( id != PIPEHANDLER_OBJECT_IDENTIFIER ) )
{
iStaticObjIdTable.Append( new TStaticId( id, id ) );
}
else
{
iStaticObjIdTable.Append( new TStaticId( id, 0xEE ) );
}
}
// Map all the kernel channels as they used to be
#endif // WITHOUT_WRAPPERS_IN_USE
// ? vaikutus iShClientThreadContainer->DeallocateThread( iInitThread );
iStaticObjIdTable.Append( new TStaticId( 0xD11BADA1, KNotInitializedId ) );// Make sure no one can get KNotInitializedId obj id
iStaticObjIdTable.Append( new TStaticId( KCommunicationManagerUID, PN_OBJ_EVENT_MULTICAST ) );
iStaticObjIdTable.Append( new TStaticId( KNameServiceUID, PN_OBJ_ROUTING_REQ ) );
iStaticObjIdTable.Append( new TStaticId( KIsiShRouterServiceUID, ROUTER_OBJECT_IDENTIFIER ) );
iStaticObjIdTable.Append( new TStaticId( KIsiShPipeHandlerUID, PIPEHANDLER_OBJECT_IDENTIFIER ) );
iShCLTransceiver = new DISICLTransceiver( *this, iInitThread );
ASSERT_RESET_ALWAYS( iShCLTransceiver, ( EISIRouterNULLPtr1 | EDISIRouterTraceId << KClassIdentifierShift ) );
C_TRACE( ( _T( "DISIRouter::Initialize<" ) ) );
}
DISICLTransceiver::DISICLTransceiver(
DISIRouter& aRouter,
TDfcQue* aThreadPtr
)
: iShRouter( aRouter )
{
C_TRACE( ( _T( "DISICLTransceiver::DISICLTransceiver>" ) ) );
ASSERT_RESET_ALWAYS( aThreadPtr, ( EISICLTransceiverNULLPtr7 | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
iShStateChangedDfc = new TDfc( StateChangedDfc, this, aThreadPtr, KDfcPriority );
ASSERT_RESET_ALWAYS( iShStateChangedDfc, ( EISICLTransceiverMemAllocFailure6 | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
iRxQueueDfc = new TDfc( RxQueueDfc, this, aThreadPtr, KDfcPriority );
ASSERT_RESET_ALWAYS( iShStateChangedDfc, ( EISICLTransceiverMemAllocFailure8 | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
DISIDevice* dev = new DISIDevice( PN_DEV_MODEM,
MISIRouterLinkIf::CreateLinkF( this, PN_MEDIA_MODEM_HOST_IF, ETrxSharedMemory)
);
ASSERT_RESET_ALWAYS( dev, ( EISICLTransceiverMemAllocFailure3 | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
iShDevices.Append( dev );
#ifdef USE_MEDIAAPI
DISIDevice* dev2 = new DISIDevice( PN_DEV_PC, // append to dynamic table if needed
MISIRouterLinkIf::CreateLinkF( this, PN_MEDIA_USB, ETrxUSB )
);
ASSERT_RESET_ALWAYS( dev2, ( EISICLTransceiverMemAllocFailure9 | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
iShDevices.Append( dev2 );
DISIDevice* dev4 = new DISIDevice( PN_DEV_PC, // append to dynamic table if needed
MISIRouterLinkIf::CreateLinkF( this, PN_MEDIA_BT, ETrxBT )
);
ASSERT_RESET_ALWAYS( dev4, ( EISICLTransceiverMemAllocFailure10 | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
iShDevices.Append( dev4 );
#endif /* USE_MEDIAAPI */
DISIDevice* dev3 = new DISIDevice( PN_DEV_DUMMYIST,
MISIRouterLinkIf::CreateLinkF( this, PN_MEDIA_TEST, ETrxTest )
);
ASSERT_RESET_ALWAYS( dev3, ( EISICLTransceiverMemAllocFailure5 | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
iShDevices.Append( dev3 );
iRouterService = new DIsiRouterService( *this );
ASSERT_RESET_ALWAYS( iRouterService, ( EISICLTransceiverMemAllocFailure2 | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
iRxQueue = new DISIMsgQueue( KISIMainRxQueueSize );
ASSERT_RESET_ALWAYS( iRxQueue, ( EISICLTransceiverMemAllocFailure7 | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
TInt err( Kern::MutexCreate( iDynamicDeviceTableMutex, KISICLTransceiverMutex, KMutexOrdGeneral0 ) );
ASSERT_RESET_ALWAYS( ( KErrNone == err ), ( EISICLTransceiverMutexCreateFailed | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
#ifdef USE_MEDIAAPI
iDevPcLastSendTrxId = EAmountOfTrxs; //put a maxvalue
iDevPcLastActiveTrxId = EAmountOfTrxs; //put a maxvalue
#endif /* USE_MEDIAAPI */
C_TRACE( ( _T( "DISICLTransceiver::DISICLTransceiver<" ) ) );
}
TUint8 DISIRouter::ReserveStaticObjId( const TInt32 aUID )
{
C_TRACE( ( _T( "DISIRouter::ReserveStaticObjId 0x%x 0x%x>" ), aUID ) );
for( TUint8 i = 0; i < iStaticObjIdTable.Count(); i++ )
{
if( iStaticObjIdTable[ i ]->iUID == aUID )
{
C_TRACE( ( _T( "DISIRouter::ReserveStaticObjId 0x%x 0x%x 0x%x<" ), aUID, iStaticObjIdTable[i]->iUID, iStaticObjIdTable[i]->iObjId ) );
return iStaticObjIdTable[i]->iObjId;
}
}
return KNotInitializedId;
}
TBool DISIKernelChannel::DISIKernelAsyncRequests::IsPending(
const TUint aRequest
)
{
C_TRACE( ( _T( "DISIKernelAsyncRequests::IsPending %d>" ), aRequest ) );
ASSERT_RESET_ALWAYS( ( EISILastAsyncRequest > aRequest && EISIAsyncReceive <= aRequest ), ( EISIKernelChannelOverTheLimits3 | EDISIKernelChannelId << KClassIdentifierShift ) );
TBool ret( EFalse );
NKern::FMWait( iRequestLock );
ret = ( iDfcFunctionList[ aRequest ] && iRequestStatusList[ aRequest ] ) ? ETrue : EFalse;
NKern::FMSignal( iRequestLock );
C_TRACE( ( _T( "DISIKernelAsyncRequests::IsPending %d %d<" ), aRequest, ret ) );
return ret;
}
void DISIRouter::Disconnect(
const TUint8 aObjId
)
{
C_TRACE( ( _T( "DISIRouter::Disconnect 0x%x>" ), aObjId ) );
TISIClient* tmp = iClientTable[ aObjId ];
NKern::FMWait( iClientTableFastMutex );
iClientTable[ aObjId ] = NULL;
NKern::FMSignal( iClientTableFastMutex );
//Must exist
delete tmp;
tmp = NULL;
C_TRACE( ( _T( "DISIRouter::Disconnect 0x%x<" ), aObjId ) );
}
DISIRouter::DISIRouter(
// None
)
{
C_TRACE( ( _T( "DISIRouter::DISIRouter>" ) ) );
iShClientThreadContainer = new DISIThreadContainer();
ASSERT_RESET_ALWAYS( iShClientThreadContainer, ( EISIRouterMemAllocFailure1 | EDISIRouterTraceId << KClassIdentifierShift ) );
iInitThread = iShClientThreadContainer->AllocateThread( MISIObjectRouterIf::EISIKernelMainThread );
ASSERT_RESET_ALWAYS( iInitThread, ( EISIRouterNULLThreadPointer | EDISIRouterTraceId << KClassIdentifierShift ) );
iInitializeDfc = new TDfc( InitializeDfc, this, iInitThread, KDfcPriority );
ASSERT_RESET_ALWAYS( iInitializeDfc, ( EISIRouterMemAllocFailure2 | EDISIRouterTraceId << KClassIdentifierShift ) );
iInitializeDfc->Enque();
C_TRACE( ( _T( "DISIRouter::DISIRouter<" ) ) );
}
