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 ) );
}
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;
}
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<" ) ) );
}
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<" ) ) );
}
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<" ) ) );
}
DISICLTransceiver::DISIDevice::DISIDevice(
const TUint8 aDeviceIdentifier,
MISIRouterLinkIf* aLink
)
{
C_TRACE( ( _T( "DISICLTransceiver::DISIDevice::DISIDevice 0x%x 0x%x 0x%x>" ), aDeviceIdentifier, aLink ) );
iShDeviceIdentifier = aDeviceIdentifier;
iShOldDeviceConnectedState = EFalse;
ASSERT_RESET_ALWAYS( aLink, ( EISICLTransceiverNULLPtr2 | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
iShLink = aLink;
iShDeviceMutex = new NFastMutex();
ASSERT_RESET_ALWAYS( iShDeviceMutex, EISICLTransceiverNULLPtr6 | EDISICLTransceiverTraceId << KClassIdentifierShift );
C_TRACE( ( _T( "DISICLTransceiver::DISIDevice::DISIDevice<" ) ) );
}
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 ) );
}
// -----------------------------------------------------------------------------
// E32Dll
// Epoc Kernel Architecture 2 style entry point
// ( other items were commented in a header ).
// -----------------------------------------------------------------------------
//
DECLARE_STANDARD_LDD()
{
DLogicalDevice* device = new DIscDevice;
if ( !device )
{
ASSERT_RESET_ALWAYS( 0,"IscDriver",EIscPanicCreateLogicalDevice );
}
return device;
}
void DISIKernelChannel::DISIKernelAsyncRequests::SetPending(
const TUint aRequest,
TDfc* aDfc,
TRequestStatus* aStatus
)
{
C_TRACE( ( _T( "DISIKernelAsyncRequests::SetPending %d 0x%x 0x%x>" ), aRequest, aDfc, aStatus ) );
ASSERT_RESET_ALWAYS( aDfc, ( EISIKernelChannelNullParam5 | EDISIKernelChannelId << KClassIdentifierShift ) );
ASSERT_RESET_ALWAYS( aStatus, ( EISIKernelChannelNullParam6 | EDISIKernelChannelId << KClassIdentifierShift ) );
ASSERT_RESET_ALWAYS( ( EISILastAsyncRequest > aRequest && EISIAsyncReceive <= aRequest ), ( EISIKernelChannelOverTheLimits2 | EDISIKernelChannelId << KClassIdentifierShift ) );
// Note asserts must be done before holding the lock.
NKern::FMWait( iRequestLock );
iDfcFunctionList[ aRequest ] = aDfc;
iRequestStatusList[ aRequest ] = aStatus;
*iRequestStatusList[ aRequest ] = KRequestPending;
NKern::FMSignal( iRequestLock );
C_TRACE( ( _T( "DISIKernelAsyncRequests::SetPending %d 0x%x 0x%x<" ), aRequest, aDfc, aStatus ) );
}
TInt DISIKernelChannel::HandleRequest(
TThreadMessage& aMsg
)
{
C_TRACE( ( _T( "DISIKernelChannel::HandleRequest 0x%x 0x%x 0x%x>" ), this, aMsg.iValue, iObjId ) );
__ASSERT_CRITICAL;
__ASSERT_NO_FAST_MUTEX;
ASSERT_THREAD_CONTEXT_ALWAYS( ( EISIKernelChannelNotThreadContext | EDISIKernelChannelId << KClassIdentifierShift ) );
TInt valueToReturn( KErrAlreadyExists );
// Channel is not open.
if( iObjId == KNotInitializedId )
{
switch( aMsg.iValue )
{
// Only connect is legal
case EISIConnect:
{
C_TRACE( ( _T( "DISIKernelChannel::HandleRequest connect 0x%x" ), this ) );
valueToReturn = aMsg.SendReceive( &iKernelChMsgQue );
break;
}
default:
{
ASSERT_RESET_ALWAYS( 0, ( EISIKernelChannelWrongParam | EDISIKernelChannelId << KClassIdentifierShift ) );
break;
}
}
}
// Channel is open.
else
{
// Accept all calls except new.
if( EISIConnect != aMsg.iValue )
{
valueToReturn = aMsg.SendReceive( &iKernelChMsgQue );
}
else
{
ASSERT_RESET_ALWAYS( ( 0 ), ( EISIKernelChannelAlreadyCreated | EDISIKernelChannelId << KClassIdentifierShift ) );
}
}
C_TRACE( ( _T( "DISIKernelChannel::HandleRequest 0x%x %d 0x%x<" ), this, valueToReturn, iObjId ) );
return valueToReturn;
}
DISIKernelChannel::DISIKernelChannel(
const TUint16& aObjId
) : iKernelChMsgQue( MsgQDfc, this, NULL, KISIKernelChannelMsgQueDfcPrio )
, iObjId(KNotInitializedId)
, iUID( KNotInitializedUID )
{
C_TRACE( ( _T( "DISIKernelChannel::DISIKernelChannel 0x%x>" ), this ) );
iRouterIf = MISIObjectRouterIf::GetIf();
ASSERT_RESET_ALWAYS( iRouterIf, ( EISIKernelChannelMemAllocFailure | EDISIKernelChannelId << KClassIdentifierShift ) );
iRequests = new DISIKernelAsyncRequests( EISILastAsyncRequest );
iRx = new DISIMsgQueue( KISILddRxQueueSize );
iCompletionThread = iRouterIf->GetDfcThread( MISIObjectRouterIf::EISIUserRequestCompletionThread );
iEmptyRxDfc = new TDfc( EmptyRxDfc, this, iCompletionThread, KISIKernelEmptyRxQueuePrio );
ASSERT_RESET_ALWAYS( ( iEmptyRxDfc && iRequests && iRx ), ( EISIKernelChannelMemAllocFailure1 | EDISIKernelChannelId << KClassIdentifierShift ) );
iMainThread = iRouterIf->GetDfcThread( MISIObjectRouterIf::EISIKernelMainThread );
iKernelChMsgQue.SetDfcQ( iMainThread );
iKernelChMsgQue.Receive();
C_TRACE( ( _T( "DISIKernelChannel::DISIKernelChannel 0x%x<" ), this ) );
}
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<" ) ) );
}
// -----------------------------------------------------------------------------
// DIscDevice::InitializeLdd2LddInterface
// Function to connect to DataTransmission and Multiplexer ldds
// ( other items were commented in a header ).
// -----------------------------------------------------------------------------
//
TInt DIscDevice::InitializeLdd2LddInterface()
{
C_TRACE( ( _T( "DIscDevice::InitializeLdd2LddInterface()" ) ) );
// Find pointer to second level LDD.
DObjectCon* lDevices = Kern::Containers()[ ELogicalDevice ];
TKName driverName;
ASSERT_RESET_ALWAYS( lDevices, "IscDriver", EIscLogicalDevicesNotFound );
TInt err( KErrNone );
//TInt driverHandle( KErrNone ); // API change in SOS9.2 WK08
TFindHandle driverHandle;
// Find pointer to ISC Multiplexer.
err = lDevices->FindByName( driverHandle, KIscMultiplexerName, driverName );
if( KErrNone != err )
{
C_TRACE( ( _T( "DIscDevice::InitializeLdd2LddInterface() ISC Multiplexer Not Found!" ) ) );
ASSERT_RESET_ALWAYS( 0, "IscDriver" ,EIscMultiplexerNotFound );
}
iIscMultiplexerInterface = static_cast<DIscMultiplexerBase*>( lDevices->At( driverHandle ) );
ASSERT_RESET_ALWAYS( iIscMultiplexerInterface, "IscDriver", EIscMultiplexerNotFound );
//TInt secondDriverHandle( KErrNone ); // API change in SOS9.2 WK08
TFindHandle secondDriverHandle;
// Find pointer to Data Transmission Plugin.
err = lDevices->FindByName( secondDriverHandle, KIscDataTransmissionDriverName, driverName );
if( KErrNone != err )
{
C_TRACE( ( _T( "DIscDevice::InitializeLdd2LddInterface() Data Transmission Plug-In Not Found!" ) ) );
ASSERT_RESET_ALWAYS( 0, "IscDriver", EIscDataTransmissionDriverNotFound );
}
iIscDataTransmissionInterface = static_cast<DIscDataTransmissionBase*>( lDevices->At( secondDriverHandle ) );
ASSERT_RESET_ALWAYS( iIscDataTransmissionInterface, "IscDriver", EIscDataTransmissionDriverNotFound );
iIscDataTransmissionInterface->Connect( this );
iIscMultiplexerInterface->Connect( this );
C_TRACE( ( _T( "DIscDevice::InitializeLdd2LddInterface - return 0x%x" ), err ) );
return err;
}
void DISIRouter::Connect(
const TInt32 aUID,
TUint8& aObjId,
MISIRouterObjectIf* aCallback
)
{
C_TRACE( ( _T( "DISIRouter::Connect 0x%x 0x%x 0x%x 0x%x>" ), aUID, aObjId, aCallback, this ) );
ASSERT_RESET_ALWAYS( aCallback, ( EISIRouterNULLPtr | EDISIRouterTraceId << KClassIdentifierShift ) );
TISIClient* tmp = new TISIClient();
ASSERT_RESET_ALWAYS( tmp, ( EISIRouterMemAllocFailure | EDISIRouterTraceId << KClassIdentifierShift ) );
tmp->iUID = aUID;
tmp->iChannel = aCallback;
TUint8 staticObjId = ReserveStaticObjId( aUID );
NKern::FMWait( iClientTableFastMutex );
TBool reserved = CheckUIDUniqueness( aUID );
#ifndef WITHOUT_WRAPPERS_IN_USE
if( reserved )
{
NKern::FMSignal( iClientTableFastMutex );
aObjId = 0xEE;
}
else
{
#endif //WITHOUT_WRAPPERS_IN_USE
if( KNotInitializedId == staticObjId )
{
tmp->iObjId = ReserveNewDynamicObjId();
ASSERT_RESET_ALWAYS( tmp->iObjId, ( EISIRouterNULLObjId | EDISIRouterTraceId << KClassIdentifierShift ) );
}
else
{
tmp->iObjId = staticObjId;// check that dynamic allocation don't return statically reserved object identifiers
}
iClientTable[ tmp->iObjId ] = tmp;
NKern::FMSignal( iClientTableFastMutex );
aObjId = tmp->iObjId;
#ifndef WITHOUT_WRAPPERS_IN_USE
}
#endif
C_TRACE( ( _T( "DISIRouter::Connect 0x%x 0x%x 0x%x<" ), aUID, aObjId, aCallback ) );
}
void DISIKernelChannel::DISIKernelAsyncRequests::Complete(
const TUint aRequest,
const TInt aStatusToComplete
)
{
C_TRACE( ( _T( "DISIKernelAsyncRequests::Complete %d>" ), aRequest ) );
// Check that request is legal.
ASSERT_RESET_ALWAYS( ( EISILastAsyncRequest > aRequest && EISIAsyncReceive <= aRequest ), ( EISIKernelChannelOverTheLimits4 | EDISIKernelChannelId << KClassIdentifierShift ) );
NKern::FMWait( iRequestLock );
TDfc* completeDfc = iDfcFunctionList[ aRequest ];
if( ( completeDfc && iRequestStatusList[ aRequest ] ) )
{
// Writing straight to clients pointer. There is a risk that malfunctioning client can mess up it's own pointer, if used out side of rx dfc, but what can you do..
*iRequestStatusList[ aRequest ] = aStatusToComplete;
ASSERT_RESET_ALWAYS( !completeDfc->Queued(), ( EISIKernelChannelDfcAlreadyQueued | EDISIKernelChannelId << KClassIdentifierShift ) );
completeDfc->Enque();
iDfcFunctionList[ aRequest ] = NULL;
}
NKern::FMSignal( iRequestLock );
C_TRACE( ( _T( "DISIKernelAsyncRequests::Complete %d<" ), aRequest ) );
}
EXPORT_C TDfcQue* DIsaAccessExtension::GetDFCThread
(
TIADDfcThread aDfcThread
)
{
C_TRACE( ( _T( "DIsaAccessExtension::GetDFCThread <->" ) ) );
ASSERT_RESET_ALWAYS( ( EIADLddDfcQueue == aDfcThread || EIADExtensionDfcQueue == aDfcThread ), EIADDFCThreadGetFailed | EIADFaultIdentifier2 << KFaultIdentifierShift );
// Ownership not given to caller.
return iDfcQueueList[ EIADExtensionDfcQueue ];//SMPSAFE
}
// 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 ) );
}
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 DISIKernelChannel::HandleThreadMsg(
TThreadMessage& aMsg
)
{
C_TRACE( ( _T( "DISIKernelChannel::HandleThreadMsg 0x%x 0x%x 0x%x>" ), this, &aMsg, iObjId ) );
TThreadMessage& m = ( aMsg );
TInt completeValue( KErrNone );
TBool complete( ETrue );
switch( m.iValue )
{
// All asynchronous requests. Return result after DFC function is run.
case EISIAsyncReceive:
{
// No need to check return value in async functions, completed to client from DFC.
HandleDfcRequest( m );
break;
}
// From synchronized request return the result immediately
case EISIConnect:
case EISIDisconnect:
case EISIAllocateBlock:
case EISIDeallocateBlock:
case EISISend:
{
completeValue = HandleSyncRequest( m );
break;
}
case KDestroyChannelMsg:
{
completeValue = KErrNone;
// Don't receive anymore messages.
complete = EFalse;
break;
}
case KMaxTInt:
{
completeValue = KErrNone;
DoCancel( KMaxTInt, m.Int0() );
break;
}
default:
{
ASSERT_RESET_ALWAYS( 0, ( EISIKernelChannelWrongRequest | EDISIKernelChannelId << KClassIdentifierShift ) );
break;
}
}
m.Complete( completeValue, complete );
C_TRACE( ( _T( "DISIKernelChannel::HandleThreadMsg 0x%x< 0x%x" ), this, iObjId ) );
}
DIsaAccessExtension::DIsaAccessExtension
(
// None
)
{
C_TRACE( ( _T( "DIsaAccessExtension::DIsaAccessExtension ->" ) ) );
// One above DFCQue0 (27)
TInt defaultDfcPriority( 27 ); //TODO: NOTE!!! change to use DFCQue0 priority if possible //Kern::DfcQue0()->iThread->iPriority; NOTE!! IST prios
// LDD DFC queue.
TDfcQue* lddTDfcQueue = NULL;
ASSERT_RESET_ALWAYS( KErrNone == Kern::DfcQCreate( lddTDfcQueue, defaultDfcPriority + KIADLddPrioriAdd, &KIADLddDfc ), EIADDFCThreadCreationFailed );
iDfcQueueList[ EIADLddDfcQueue ] = lddTDfcQueue;
// Extension DFC queue.
TDfcQue* extensionTDfcQueue = NULL;
ASSERT_RESET_ALWAYS( KErrNone == Kern::DfcQCreate( extensionTDfcQueue, defaultDfcPriority + KIADExtensionPrioriAdd, &KIADExtensionDfc ), EIADDFCThreadCreationFailed );
iDfcQueueList[ EIADExtensionDfcQueue ] = extensionTDfcQueue;
C_TRACE( ( _T( "DIsaAccessExtension::DIsaAccessExtension <-" ) ) );
iRouter = new DRouter();
ASSERT_RESET_ALWAYS( iRouter, EIADMemoryAllocationFailure | EIADFaultIdentifier4 << KFaultIdentifierShift );
// _LIT8( KIADCOMPONAME, "ISA ACCESS DRIVER" );
//BUILD_TRACE( KIADCOMPONAME() );
}
void DISICLTransceiver::DynamicToStaticDevice( TUint8& aRxDev )
{
C_TRACE( ( _T( "DISICLTransceiver::DynamicToStaticDevice aRxDev>" ), &aRxDev ) );
TInt err( Kern::MutexWait( *iDynamicDeviceTableMutex ) );
ASSERT_RESET_ALWAYS( ( err == KErrNone ), ( EISICLTransceiverMutexWaitFailed | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
for( TUint8 i = 0; i < iDynamicDeviceTable.Count(); i++ )
{
if( iDynamicDeviceTable[ i ]->iDynamicDevId == aRxDev )
{
C_TRACE( ( _T( "DISICLTransceiver::DynamicToStaticDevice dyn dev exist i = %d iDynamicDevId 0x%x iStaticDevId 0x%x" ), i, iDynamicDeviceTable[ i ]->iDynamicDevId, iDynamicDeviceTable[ i ]->iStaticDevId) );
aRxDev = iDynamicDeviceTable[ i ]->iStaticDevId;
break;
}
}
Kern::MutexSignal( *iDynamicDeviceTableMutex );
C_TRACE( ( _T( "DISICLTransceiver::DynamicToStaticDevice aRxDev<" ), &aRxDev ) );
}
void DISICLTransceiver::ReadStateChanges(
// None
)
{
C_TRACE( ( _T( "DISICLTransceiver::ReadStateChanges>" ) ) );
const TInt count( iShDevices.Count() );
for( TInt index( 0 ); index < count; index++ )
{
DISIDevice* tmpDevice = iShDevices[ index ];
ASSERT_RESET_ALWAYS( tmpDevice, ( EISICLTransceiverNULLPtr6 | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
tmpDevice->LockDeviceFM();
const TBool connected = tmpDevice->GetDeviceState();// tee paremmaksi
#ifdef USE_MEDIAAPI
MISIRouterLinkIf* link = NULL;
link = tmpDevice->GetLink();
#endif /* USE_MEDIAAPI */
if( connected != tmpDevice->GetDeviceOldState() )
{
tmpDevice->SetDeviceOldState( connected );
const TUint8 deviceIdentifier = tmpDevice->GetDeviceIdentifier();
tmpDevice->FreeDeviceFM();
#ifdef USE_MEDIAAPI
C_TRACE( ( _T( "DISICLTransceiver::ReadStateChanges trxid 0x%x state changed>" ),link->GetTrxId() ) );
if( (link->GetTrxId() == iDevPcLastSendTrxId) && (!connected) )
{
C_TRACE( ( _T( "DISICLTransceiver::ReadStateChanges trxid 0x%x disconneted>" ),link->GetTrxId() ) );
iDevPcLastSendTrxId = iDevPcLastActiveTrxId;
iDevPcLastActiveTrxId = EAmountOfTrxs; //put a maxvalue
}
#endif /* USE_MEDIAAPI */
iRouterService->SendDeviceConnectionStateChangedInd( connected, deviceIdentifier );
}
else
{
tmpDevice->FreeDeviceFM();
}
}
C_TRACE( ( _T( "DISICLTransceiver::ReadStateChanges<" ) ) );
}
void DISIKernelChannel::HandleDfcRequest(
TThreadMessage& aMsg
)
{
C_TRACE( ( _T( "DISIKernelChannel::HandleDfcRequest 0x%x 0x%x 0x%x>" ), this, &aMsg, iObjId ) );
TThreadMessage& m = ( aMsg );
TInt request( m.iValue );
ASSERT_RESET_ALWAYS( m.iArg, ( EISIKernelChannelNullParam | EDISIKernelChannelId << KClassIdentifierShift ) );
ASSERT_RESET_ALWAYS( EISILastAsyncRequest > ( request ), ( EISIKernelChannelWrongRequest1 | EDISIKernelChannelId << KClassIdentifierShift ) );
if( iRequests->IsPending( request) )
{
C_TRACE( ( _T( "DISIKernelChannel::HandleDfcRequest existing 0x%x request 0x%x" ), this, request ) );
// Should not give same request object twice before completing the first one.
ASSERT_RESET_ALWAYS( 0, ( EISIKernelChannelSameRequestTwice | iObjId << KObjIdShift | static_cast<TUint8>( request ) << KExtraInfoShift ) );
}
else
{
C_TRACE( ( _T( "DISIKernelChannel::HandleDfcRequest 0x%x handling %d" ), this, request ) );
TUint32* tablePtr = reinterpret_cast<TUint32*>( m.Ptr0() );
TRequestStatus* dfcStatus = reinterpret_cast<TRequestStatus*>( tablePtr[ KFirstParam ] );
TDfc* dfc = reinterpret_cast<TDfc*>( tablePtr[ KThirdParam ] );
ASSERT_RESET_ALWAYS( dfcStatus, ( EISIKernelChannelNullParam2 | EDISIKernelChannelId << KClassIdentifierShift ) );
ASSERT_RESET_ALWAYS( dfc, ( EISIKernelChannelNullParam3 | EDISIKernelChannelId << KClassIdentifierShift ) );
iRequests->SetPending( request, dfc, dfcStatus );
switch( request )
{
case EISIAsyncReceive:
{
ASSERT_RESET_ALWAYS( !iPtrPtrToRxBuf, ( EISIKernelChannelRxBufferNotReleased | EDISIKernelChannelId << KClassIdentifierShift ) );
iPtrPtrToRxBuf = reinterpret_cast<TDes8**>( tablePtr[ KSecondParam ] );
C_TRACE( ( _T( "DISIKernelChannel::HandleDfcRequest EIADAsyncReceive 0x%x 0x%x 0x%x" ), this, iPtrPtrToRxBuf, &iPtrPtrToRxBuf ) );
iEmptyRxDfc->Enque();
break;
}
default:
{
ASSERT_RESET_ALWAYS( 0, ( EISIKernelChannelWrongRequest2 | EDISIKernelChannelId << KClassIdentifierShift ) );
break;
}
}
}
C_TRACE( ( _T( "DISIKernelChannel::HandleDfcRequest 0x%x 0x%x 0x%x<" ), this, &aMsg, iObjId ) );
}
// -----------------------------------------------------------------------------
// DIscDevice::Install
// Complete the installation of driver
// ( other items were commented in a header ).
// -----------------------------------------------------------------------------
//
TInt DIscDevice::Install()
{
C_TRACE( ( _T( "DIscDevice::Install()" ) ) );
// Dfc for sending frames
iSendDfc = new TDfc( Flush, this, Kern::DfcQue0(), KSendDfcPriority );
iNotifyDfc = new TDfc( NotifyConnection, this, Kern::DfcQue0(), KNotifyDfcPriority );
ASSERT_RESET_ALWAYS( iSendDfc, "IscDriver",EIscMemoryAllocationFailure );
//Initialize IscChannelContainer
IscChannelContainer::Initialize();
// connect to multiplexer and data transmission driver
TInt r = InitializeLdd2LddInterface();
if ( r != KErrNone )
{
TRACE_ASSERT_ALWAYS;
return r;
}
return ( SetName( &KIscDriverName ) );
}
DIsaAccessExtension::~DIsaAccessExtension
(
// None
)
{
C_TRACE( ( _T( "DIsaAccessExtension::~DIsaAccessExtension ->" ) ) );
// Never unloaded so no actual need for these, but we could test memory allocations
// and deallocations if we destroy this extension in test code.
delete iRouter;
iRouter = NULL;
for( TInt i( 0 ); i < EIADSizeOfDfcThreadList; ++i )
{
TDfcQue* dfcQueueToBeDeleted = GetDFCThread( static_cast< TIADDfcThread >( i ) );
ASSERT_RESET_ALWAYS( dfcQueueToBeDeleted, EIADDFCThreadGetFailed | EIADFaultIdentifier1 << KFaultIdentifierShift );
delete dfcQueueToBeDeleted;
dfcQueueToBeDeleted = NULL;
}
iDfcQueueList[ EIADLddDfcQueue ] = NULL;
iDfcQueueList[ EIADExtensionDfcQueue ] = NULL;
C_TRACE( ( _T( "DIsaAccessExtension::~DIsaAccessExtension <-" ) ) );
}
TBool DISIRouter::CheckUIDUniqueness( const TInt32 aUID )
{
TBool ret(EFalse);
// No tracing with mutex
for( TInt i( 0 ); i < KMaxAmountOfObjId; i++ )
{
if( iClientTable[ i ] && ( iClientTable[ i ]->iUID == aUID ) )
{
#ifndef WITHOUT_WRAPPERS_IN_USE
if( aUID <= KLastKernelChannel )
{
ret = ETrue;
}
else
{
#endif //WITHOUT_WRAPPERS_IN_USE
ASSERT_RESET_ALWAYS( 0, ( EISIRouterNotUniqueUID | EDISIRouterTraceId << KClassIdentifierShift ) );
#ifndef WITHOUT_WRAPPERS_IN_USE
}
#endif //WITHOUT_WRAPPERS_IN_USE
}
}
return ret;
}
// -----------------------------------------------------------------------------
// DIscDevice::Initialize
// Complete the initialization of driver
// ( other items were commented in a header ).
// -----------------------------------------------------------------------------
//
void DIscDevice::Initialize()
{
C_TRACE( ( _T( "DIscDevice::Initialize()" ) ) );
TInt i( 0 );
// Get buffer configuration data from multiplexer
TIscConfiguration configData;
iIscMultiplexerInterface->GetConfiguration( configData );
// Create main buffer
iIscMainRcvBuffer = new DIscMainRcvBuffer( this, configData.mainRcvQueueSize );
ASSERT_RESET_ALWAYS( iIscMainRcvBuffer, "IscDriver",EIscMemoryAllocationFailure );
// Do second phase installation
iIscMainRcvBuffer->DoCreate();
// Create queue for sending frames
iSend = new TUint32*[configData.channelSendQueueSize];
ASSERT_RESET_ALWAYS( iSend, "IscDriver",EIscMemoryAllocationFailure );
iSendFrameParameters = new TIscSendFrameInfo*[configData.channelSendQueueSize];
for ( i = 0; i < configData.channelSendQueueSize; i++ )
{
iSendFrameParameters[i] = new TIscSendFrameInfo;
}
ASSERT_RESET_ALWAYS( iSendFrameParameters, "IscDriver",EIscMemoryAllocationFailure );
iSendQueue = new DIscSendQueue( iSend, iSendFrameParameters, configData.channelSendQueueSize );
ASSERT_RESET_ALWAYS( iSendQueue, "IscDriver",EIscMemoryAllocationFailure );
// create temporary queue
iTempSend = new TUint32*[configData.channelSendQueueSize];
ASSERT_RESET_ALWAYS( iTempSend, "IscDriver",EIscMemoryAllocationFailure );
iTempFrameParameters = new TIscSendFrameInfo*[configData.channelSendQueueSize];
for ( i =0; i < configData.channelSendQueueSize; i++ )
{
iTempFrameParameters[i] = new TIscSendFrameInfo;
}
ASSERT_RESET_ALWAYS( iTempFrameParameters, "IscDriver",EIscMemoryAllocationFailure );
iTempQueue = new DIscSendQueue( iTempSend, iTempFrameParameters, configData.channelSendQueueSize );
ASSERT_RESET_ALWAYS( iTempQueue, "IscDriver",EIscMemoryAllocationFailure );
// Create send queue for control channel
iControlSend = new TUint32*[configData.channelSendQueueSize];
ASSERT_RESET_ALWAYS( iControlSend, "IscDriver",EIscMemoryAllocationFailure );
iControlFrameParameters = new TIscSendFrameInfo*[configData.channelSendQueueSize];
for ( i = 0; i < configData.channelSendQueueSize; i++ )
{
iControlFrameParameters[i] = new TIscSendFrameInfo;
}
ASSERT_RESET_ALWAYS( iControlFrameParameters, "IscDriver",EIscMemoryAllocationFailure );
iControlSendQueue = new DIscSendQueue( iControlSend, iControlFrameParameters, configData.channelSendQueueSize );
ASSERT_RESET_ALWAYS( iControlSendQueue, "IscDriver",EIscMemoryAllocationFailure );
iIscDataTransmissionInterface->AllocBuffers( configData.bufferConfig );
iConnectionStatus = iIscDataTransmissionInterface->ConnectionStatus();
iIscMultiplexerInterface->NotifyConnectionStatus( iConnectionStatus );
C_TRACE( ( _T( "DIscDevice::Initialize - return void" ) ) );
}
TInt DISICLTransceiver::RouteISIMessage(
TDes8& aMessage,
TBool aDynamicSenderCheckNeeded
)
{
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage 0x%x 0x%x> len %d" ), &aMessage, aDynamicSenderCheckNeeded, aMessage.Length() ) );
const TUint8* msgPtr = aMessage.Ptr();
ISIMESSAGE_TRACE( aMessage );
TInt error( ValidateISIMessage( aMessage ) );
if( KErrNone != error )
{
TRACE_ASSERT_ALWAYS;
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage invalid message 0x%x" ), &aMessage ) );
MemApi::DeallocBlock( aMessage );
}
else
{
TBool sendOk( EFalse );
if ( aDynamicSenderCheckNeeded )// Save dynamic device ids from PN_DEV_OWN
{
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage from ISI Router" ) ) );
TUint8 txDeviceIdentifier = GET_SENDER_DEV( aMessage );
if ( DynamicDevice( txDeviceIdentifier ) )
{
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage from ISI Router Dynamic Dev" ) ) );
UpdateDynamicDeviceTable( txDeviceIdentifier, PN_DEV_OWN );
#ifndef USE_MEDIAAPI
ASSERT_RESET_ALWAYS( txDeviceIdentifier == PN_DEV_PC, 0xdeaddead );// only supported PN_DEV_PC with EIscNokiaUsbPhonetLink
#endif /* USE_MEDIAAPI */
}
}
TUint8 rxDeviceIdentifier = GET_RECEIVER_DEV( aMessage );
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage rxDeviceIdentifier 0x%x" ), rxDeviceIdentifier ) );
if ( DynamicDevice( rxDeviceIdentifier ) )
{
DynamicToStaticDevice( rxDeviceIdentifier );
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage rxDeviceIdentifier after 0x%x" ), rxDeviceIdentifier ) );
}
if( rxDeviceIdentifier == PN_DEV_OWN )
{
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage PN_DEV_OWN 0x%x" ), &aMessage ) );
TUint16 objId(0xffff);
#ifndef USE_MEDIAAPI
if ( GET_RECEIVER_DEV( aMessage ) == PN_DEV_PC )
{
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage to PN_DEV_PC in PN_DEV_OWN" )) );
objId = EIscNokiaUsbPhonetLink;
}
else
{
objId = GET_RECEIVER_OBJ( aMessage );
}
#endif /* USE_MEDIAAPI */
#ifdef USE_MEDIAAPI
objId = GET_RECEIVER_OBJ( aMessage );
#endif /* USE_MEDIAAPI */
sendOk = iShRouter.Receive( aMessage, objId );
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage PN_DEV_OWN 0x%x ok %d" ), &aMessage, sendOk ) );
}
else
{
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage Not PN_DEV_OWN 0x%x" ), &aMessage ) );
MISIRouterLinkIf* link = NULL;
const TInt count( iShDevices.Count() );
for( TInt index( 0 ); index < count; index++ )
{
DISIDevice* tmpDevice = iShDevices[ index ];
ASSERT_RESET_ALWAYS( tmpDevice, ( EISICLTransceiverNULLPtr4 | EDISICLTransceiverTraceId << KClassIdentifierShift ) );
tmpDevice->LockDeviceFM();
if( tmpDevice->GetDeviceIdentifier() == rxDeviceIdentifier )
{
link = tmpDevice->GetLink();
tmpDevice->FreeDeviceFM();
#ifndef USE_MEDIAAPI
sendOk = link->Send( aMessage );
break;
#endif /* USE_MEDIAAPI */
#ifdef USE_MEDIAAPI
if ( GET_RECEIVER_DEV( aMessage ) == PN_DEV_PC )
{
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage PN_DEV_PC %d, %d" ), link->GetTrxId(), iDevPcLastSendTrxId ) );
if(iDevPcLastSendTrxId < EAmountOfTrxs)
{
if ( link->GetTrxId() == iDevPcLastSendTrxId )
{
if (link->StateConnected())
{
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage PN_DEV_PC %d, Msg mediaid 0x%x" ), link->GetTrxId(), msgPtr[ ISI_HEADER_OFFSET_MEDIA ] ) );
sendOk = link->Send( aMessage );
break;
}
}
}
else
{
break;
}
}
else
{
sendOk = link->Send( aMessage );
break;
}
#endif /* USE_MEDIAAPI */
}
else
{
tmpDevice->FreeDeviceFM();
}
}
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage Not PN_DEV_OWN ok %d" ), &aMessage, sendOk ) );
}
if( !sendOk )
{
TRACE_ASSERT_ALWAYS;
error = SendCommIsaEntityNotReachableResp( aMessage );
}
}
C_TRACE( ( _T( "DISICLTransceiver::RouteISIMessage 0x%x<" ), &aMessage ) );
return error;
}
TInt DISIKernelChannel::HandleSyncRequest(
TThreadMessage& aMsg
)
{
C_TRACE( ( _T( "DISIKernelChannel::HandleSyncRequest 0x%x 0x%x 0x%x>" ), this, &aMsg, iObjId ) );
TThreadMessage& m = ( aMsg );
TInt request( m.iValue );
ASSERT_RESET_ALWAYS( m.iArg, ( EISIKernelChannelNullParam4 | EDISIKernelChannelId << KClassIdentifierShift ) );
TInt returnValue( KErrNone );
C_TRACE( ( _T( "DISIKernelChannel::HandleSyncRequest 0x%x handling %d" ), this, request ) );
TUint32* tablePtr = reinterpret_cast<TUint32*>( m.Ptr0() );
switch( request )
{
case EISIConnect:
{
C_TRACE( ( _T( "DISIKernelChannel::HandleSyncRequest EISIConnect 0x%x" ), this ) );
iUID = tablePtr[ KFirstParam ];
TUint8* objIdPtr = reinterpret_cast<TUint8*>( tablePtr[ KSecondParam ] );
C_TRACE( ( _T( "DISIKernelChannel::HandleDfcRequest EISINokiaKernelOpen 0x%x" ), this ) );
iRouterIf->Connect( iUID, iObjId, this );
*objIdPtr = iObjId;
C_TRACE( ( _T( "DISIKernelChannel::HandleSyncRequest EISIConnect 0x%x" ), this ) );
break;
}
case EISIDisconnect:
{
C_TRACE( ( _T( "DISIKernelChannel::HandleSyncRequest EISIDisconnect 0x%x" ), this ) );
Disconnect();
C_TRACE( ( _T( "DISIKernelChannel::HandleSyncRequest EISIDisconnect 0x%x" ), this ) );
returnValue = KErrNone;
break;
}
case EISIAllocateBlock:
{
C_TRACE( ( _T( "DISIKernelChannel::HandleSyncRequest EISIAllocateBlock 0x%x" ), this ) );
const TInt size = *reinterpret_cast<TInt*>( tablePtr[ KFirstParam ] );
TDes8*& block = *(reinterpret_cast<TDes8**>( tablePtr[ KSecondParam ] ));
C_TRACE( ( _T( "DISIKernelChannel:: EISIAllocateBlock 0x%x block 0x%x %d" ), this, block, size ) );
block = ( &MemApi::AllocBlock( size ) );
C_TRACE( ( _T( "DISIKernelChannel::HandleSyncRequest EISIAllocateBlock 0x%x" ), this ) );
break;
}
case EISIDeallocateBlock:
{
C_TRACE( ( _T( "DISIKernelChannel::HandleSyncRequest EISIDeallocateBlock 0x%x" ), this ) );
TDes8& block = *reinterpret_cast<TDes8*>( tablePtr[ KFirstParam ] );
C_TRACE( ( _T( "DISIKernelChannel::HandleSyncRequest EISIAllocateBlock 0x%x block 0x%x" ), this, &block ) );
// Needed to ensure that right channel is deleting the right block. (Could it be done otherways too?)
if( iPtrPtrToRxBuf )
{
if ( &block == *iPtrPtrToRxBuf )
{
C_TRACE( ( _T( "DISIKernelChannel::HandleSyncRequest release 0x%x 0x%x clientRx 0x%x"), iPtrPtrToRxBuf, &iPtrPtrToRxBuf, *iPtrPtrToRxBuf ) );
iPtrPtrToRxBuf = NULL;
}
}
MemApi::DeallocBlock( block );
C_TRACE( ( _T( "DISIKernelChannel::HandleSyncRequest EISIDeallocateBlock 0x%x" ), this ) );
break;
}
case EISISend:
{
C_TRACE( ( _T( "DISIKernelChannel::HandleSyncRequest EISISend 0x%x" ), this ) );
TDes8& block = *reinterpret_cast<TDes8*>( tablePtr[ KFirstParam ] );
C_TRACE( ( _T( "DISIKernelChannel::HandleSyncRequest EISISend 0x%x block 0x%x" ), this, &block ) );
returnValue = iRouterIf->Send( block, iObjId );
C_TRACE( ( _T( "DISIKernelChannel::HandleSyncRequest EISISend 0x%x" ), this ) );
break;
}
default:
{
ASSERT_RESET_ALWAYS( 0, ( EISIKernelChannelWrongRequest3 | EDISIKernelChannelId << KClassIdentifierShift ) );
break;
}
}
C_TRACE( ( _T( "DISIKernelChannel::HandleSyncRequest 0x%x 0x%x %d 0x%x<" ), this, &aMsg, returnValue, iObjId ) );
return returnValue;
}
