diff -r e71858845f73 -r e1758cbb96ac systemswstubs/examplecommonisc/IscApi/src/IscApi.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/systemswstubs/examplecommonisc/IscApi/src/IscApi.cpp Mon Oct 04 00:04:35 2010 +0300 @@ -0,0 +1,1230 @@ +/* +* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "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: Implementation of RIscApi class +* +*/ + + + +// INCLUDE FILES +#include +#include +#include +#include +#include +#include "IscTrace.h" + +// EXTERNAL DATA STRUCTURES + +// EXTERNAL FUNCTION PROTOTYPES + +// CONSTANTS +_LIT( KIscApiPanic,"IscApi Panic" ); +_LIT( KIscDriverName,"IscDriver" ); +_LIT( KIscDriverExtensionName,"IscDriverExtension" ); + +// MACROS + +// LOCAL CONSTANTS AND MACROS +_LIT( KIniFile,"Z:\\resource\\ISC\\isc_config.ini" ); +_LIT( KMultiplexerLdd,"MultiplexerLdd" ); +_LIT( KDataTransmissionLdd,"DataTransmissionLdd" ); +_LIT( KDataTransmissionPdd,"DataTransmissionPdd" ); +_LIT( KPdd,"PDD" ); +_LIT( KLdd,"LDD" ); +_LIT( KHashSign,"#" ); +_LIT( KSemiColon,";" ); +_LIT( KEqualSign,"=" ); + +_LIT( KIscDriverLdd, "iscdriver.ldd" ); +_LIT( KIscDriverExtensionLdd, "iscdriverextension.ldd" ); + +const TInt KZeroLength( KErrNone ); +const TInt KStartPosition( KErrNone ); +const TInt KOneParam( 1 ); +const TInt KTwoParams( 2 ); +const TInt KThreeParams( 3 ); +const TInt KFirstParam( 0 ); +const TInt KSecondParam( 1 ); +const TInt KThirdParam( 2 ); +const TInt KMajor( KErrNone ); +const TInt KMinor( KErrNone ); +const TInt KBuild( KErrNone ); +const TInt KAddPosition( 1 ); +const TInt KInfoLength( 1 ); + +// MODULE DATA STRUCTURES + +// LOCAL FUNCTION PROTOTYPES + +// FORWARD DECLARATIONS + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// RIscApi::RIscApi +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C RIscApi::RIscApi() + :iNeededLen( NULL, KZeroLength ), + iNeededDataLen( NULL, KZeroLength ), + iConnectionStatus( NULL, KZeroLength ), + iFlowControlStatus( NULL, KZeroLength ), + iOpen( EFalse ), + iChannelNumber( KIscFrameReceiverNotFound ) +#ifdef __WINS__ + ,iInitializing( EFalse ) +#endif + { + } + + +EXPORT_C RIscApi::~RIscApi() + { + + if( iOpen || iChannelNumber != KIscFrameReceiverNotFound ) + { + Close(); + } + else + { + // Do nothing. + } + + } + + +// ----------------------------------------------------------------------------- +// RIscApi::Initialize +// Initialize the ISC Interface +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::InitializeModemInterface + ( + TRequestStatus& aStatus + ) + { + A_TRACE( ( _T( "RIscApi::InitializeModemInterface(0x%x)" ), &aStatus ) ); + +#ifdef __WINS__ + iInitializing = ETrue; +#endif + + CTrapCleanup* cleanup = CTrapCleanup::New(); + TInt r( KErrNone ); + TInt r2( KErrNone ); + HBufC8* multiplexerInit = NULL; + TRAP( r, ( multiplexerInit = HBufC8::NewL( KIscIniLineLength ) ) ); + // buffer to hold the init-string for second-level driver + HBufC8* dataTransmissionInit = NULL; + TRAP( r2, ( dataTransmissionInit = HBufC8::NewL( KIscIniLineLength ) ) ); + __ASSERT_ALWAYS( ( KErrNone == r && KErrNone == r2 ), + User::Panic( KIscApiPanic, EIscApiMemoryAllocationFailure ) ); + // Read ini-file and load needed drivers. + TRAP( r, LoadL( *multiplexerInit, *dataTransmissionInit ) ); + if( KErrAlreadyExists == r ) + { + TRACE_ASSERT_ALWAYS; + C_TRACE( ( _T( "RIscApi::InitializeModemInterface DRIVERS ERROR" ) ) ); + delete multiplexerInit; + multiplexerInit = NULL; + delete dataTransmissionInit; + dataTransmissionInit = NULL; + delete cleanup; + cleanup = NULL; + TRequestStatus* ptrStatus = &aStatus; + User::RequestComplete( ptrStatus, r ); + return; + } + else + { + __ASSERT_ALWAYS( ( KErrNone == r ), + User::Panic( KIscApiPanic,EIscApiDriverLoadFail ) ); + } + + // Open control channel + TInt channel( KIscControlChannel ); + TInt err = DoCreate( KIscDriverName, + TVersion( KMajor, KMinor, KBuild ), + channel, + NULL, + NULL, + EOwnerThread ); + __ASSERT_ALWAYS( KErrNone == err, + User::Panic( KIscApiPanic, EIscApiChannelCreateFail ) ); + iChannelNumber = static_cast( channel ); + iOpen = ETrue; + + TPtrC8 multiplexerInitString( multiplexerInit->Des() ); + TPtrC8 dataTransmissionInitString( dataTransmissionInit->Des() ); + TAny* params[ KThreeParams ]; + params[ KFirstParam ] = (TAny*)&aStatus; + params[ KSecondParam ] = static_cast( &multiplexerInitString ); + params[ KThirdParam ] = static_cast( &dataTransmissionInitString ); + + aStatus = KRequestPending; + //Initialize Data transmission + DoSvControl( EIscAsyncInitializeModemInterface, params ); + + delete multiplexerInit; + multiplexerInit = NULL; + delete dataTransmissionInit; + dataTransmissionInit = NULL; + delete cleanup; + cleanup = NULL; + +#ifdef __WINS__ + iInitializing = EFalse; +#endif + A_TRACE( ( _T( "RIscApi::InitializeModemInterfaceL - return void" ) ) ); + + } + +// ----------------------------------------------------------------------------- +// RIscApi::InitializeCancel +// Cancel ISC Initialization sequence +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::InitializeCancel() + { + A_TRACE( ( _T( "RIscApi::InitializeCancel()" ) ) ); + + if( iOpen && iChannelNumber == KIscControlChannel ) + { + DoControl( EIscCancelAsyncInitialize ); + } + else + { + // Do nothing if not controlchannel who is handling the initialization. + } + + A_TRACE( ( _T( "RIscApi::InitializeCancel - return void" ) ) ); + } + +// ----------------------------------------------------------------------------- +// RIscApi::LoadL +// Load required drivers using Isc_config.ini file +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +void RIscApi::LoadL + ( + const TDesC8& aMultiplexerInit, // Multiplexer init. + const TDesC8& aDataTransmissionInit // Datatransmission init. + ) const + { + C_TRACE( ( _T( "RIscApi::LoadL(0x%x, 0x%x)" ), &aMultiplexerInit, + &aDataTransmissionInit ) ); + + TInt err( KErrNone ); + TInt loadStatus( KErrNone ); + TInt pos( KErrNone ); + + // Temporary buffers. + HBufC* driverNameBuf = HBufC::NewLC( KIscIniLineLength ); + HBufC* iniFileLineBuf = HBufC::NewLC( KIscIniLineLength ); + HBufC* initStringBuf = HBufC::NewLC( KIscIniLineLength ); + // Temporary pointers. + TPtr driverName( driverNameBuf->Des() ); + TPtr initString( initStringBuf->Des() ); + TPtr iniFileLine( iniFileLineBuf->Des() ); + + RFs fsSession; + CleanupClosePushL( fsSession ); + RFile file; + CleanupClosePushL( file ); + TFileText fileText; + User::LeaveIfError( fsSession.Connect() ); + User::LeaveIfError( file.Open( fsSession, KIniFile, + EFileStreamText | EFileRead ) ); + fileText.Set( file ); + + while( KErrNone == fileText.Read( iniFileLine ) ) + { + if( KErrNone < iniFileLine.Length() ) + { + C_TRACE( ( iniFileLine ) ); + pos = KErrNotFound; + loadStatus = KErrNotFound; + if ( iniFileLine.Find( KHashSign ) != KErrNotFound ) + { + pos = KErrNone; + loadStatus = KErrNone; + } + else if ( iniFileLine.Find( KDataTransmissionPdd ) != KErrNotFound ) + { + C_TRACE( ( _T( "RIscApi::LoadL - datatransmissionpdd" ) ) ); + iniFileLine.Trim(); + pos = InifileLineParser( iniFileLine, driverName ); + if( KErrNotFound != pos ) + { + loadStatus = User::LoadPhysicalDevice( driverName ); + } + else + { + // Do nothing. + } + } + else if ( iniFileLine.Find( KDataTransmissionLdd ) != KErrNotFound ) + { + C_TRACE( ( iniFileLine ) ); + pos = InifileLineParser( iniFileLine, driverName ); + if( KErrNotFound != pos ) + { + DriverNameParser( initString, driverName, + *&aDataTransmissionInit ); + loadStatus = User::LoadLogicalDevice( driverName ); + } + else + { + // Do nothing. + } + } + else if ( iniFileLine.Find( KMultiplexerLdd ) != KErrNotFound ) + { + C_TRACE( ( iniFileLine ) ); + pos = InifileLineParser( iniFileLine, driverName ); + if( KErrNotFound != pos ) + { + DriverNameParser( initString, driverName, + *&aMultiplexerInit ); + loadStatus = User::LoadLogicalDevice( driverName ); + } + else + { + // Do nothing. + } + } + else if ( iniFileLine.Find( KPdd ) != KErrNotFound ) + { + C_TRACE( ( _T( "RIscApi::LoadL - pdd" ) ) ); + iniFileLine.Trim(); + pos = InifileLineParser( iniFileLine, driverName ); + if( KErrNotFound != pos ) + { + loadStatus = User::LoadPhysicalDevice( driverName ); + } + else + { + // Do nothing. + } + } + else if ( iniFileLine.Find( KLdd ) != KErrNotFound ) + { + RDebug::Print( _L( "RIscApi::LoadL ldd" ) ); + iniFileLine.Trim(); + pos = InifileLineParser( iniFileLine, driverName ); + if( KErrNotFound != pos ) + { + loadStatus = User::LoadLogicalDevice( driverName ); + } + else + { + // Do nothing. + } + } + __ASSERT_ALWAYS( pos != KErrNotFound, + User::Panic( KIscApiPanic, EIscApiFalseIniFile ) ); + __ASSERT_ALWAYS( KErrAlreadyExists != loadStatus, + User::Leave( loadStatus ) ); + __ASSERT_ALWAYS( KErrNone == loadStatus, + User::Panic( KIscApiPanic, EIscApiDriverLoadFail ) ); + } + else + { + C_TRACE( ( _T( "RIscApi::LoadL IniFileLength = KErrNone" ) ) ); + } + } + loadStatus = User::LoadLogicalDevice( KIscDriverLdd ); + err = User::LoadLogicalDevice( KIscDriverExtensionLdd ); + C_TRACE( ( _T( "RIscApi::LoadL drivers iscdriver %d, iscdriverext %d" ), + loadStatus, err ) ); + __ASSERT_ALWAYS( ( KErrNone == loadStatus|| KErrNone == err ), + User::Panic( KIscApiPanic, EIscApiDriverLoadFail ) ); + // R-Classes fsSession and file Close-method is called when deleted + // from CleanupStack. + CleanupStack::PopAndDestroy( KTwoParams ); + CleanupStack::PopAndDestroy( initStringBuf ); + CleanupStack::PopAndDestroy( iniFileLineBuf ); + CleanupStack::PopAndDestroy( driverNameBuf ); + C_TRACE( ( _T( "RIscApi::LoadL - return void" ) ) ); + + } + +// ----------------------------------------------------------------------------- +// IscApi::LoadLHelper +// Helps parsing the .ini file. +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +TInt RIscApi::InifileLineParser + ( + TDes& aInifileLine, + TDes& aDriverName + ) const + { + C_TRACE( ( _T( "RIscApi::InifileLineParser" ) ) ); + + TInt position( KErrNotFound ); + position = aInifileLine.Find( KEqualSign ); + if( KErrNotFound != position ) + { + // Split the string. + C_TRACE( ( aInifileLine ) ); + aDriverName.Zero(); + aDriverName.Append( aInifileLine.Mid( position + KAddPosition ) ); + aInifileLine.Delete( KStartPosition, KIscIniLineLength ); + C_TRACE( ( aDriverName ) ); + } + else + { + // Do nothing. + } + C_TRACE( ( _T( "RIscApi::InifileLineParser return %d" ), position ) ); + return position; + + } + +// ----------------------------------------------------------------------------- +// IscApi::LoadLSecondHelper +// Helps parsing the .ini file. +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +void RIscApi::DriverNameParser + ( + TDes& aInitString, + TDes& aDriverName, + const TDesC8& aString + )const + { + C_TRACE( ( _T( "RIscApi::DriverNameParser" ) ) ); + + TInt position = aDriverName.Find( KSemiColon ); + if( KErrNotFound != position ) + { + C_TRACE( ( aInitString ) ); + // Split the string. + aInitString.Zero(); + aInitString.Append( aDriverName.Mid( position + KAddPosition ) ); + aDriverName.Delete( position, KIscIniLineLength ); + C_TRACE( ( aDriverName ) ); + TPtr8 tmpPtr( ( static_cast( &const_cast( aString ) ) )->Des() ); + tmpPtr.Append( aInitString ); + C_TRACE( ( aInitString ) ); + } + else + { + // Do nothing. + } + C_TRACE( ( _T( "RIscApi::DriverNameParser return " ) ) ); + + } + +// ----------------------------------------------------------------------------- +// RIscApi::Open +// Open ISC channel asyncronously +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::Open( + const TUint16 aChannelNumber, + TRequestStatus& aStatus, + TOwnerType aType, + const TDesC8* aOpenParams ) + { + A_TRACE( ( _T( "RIscApi::Open(0x%x, 0x%x, 0x%x, 0x%x) this %x" ), + aChannelNumber, &aStatus, aType, aOpenParams, this ) ); + + // In case if async Close() is called but channel is not destructed, + // release kernel side memory allocations before actual channel opening. + if( iChannelNumber != KIscFrameReceiverNotFound && iOpen == EFalse ) + { + Close(); + } + else + { + // Do nothing. + } + +#ifdef __WINS__ + // InitializeModemInterface() must be called to load correct drivers. + // In HW this is done e.g. from EStart + + RMutex iscapiMutex; + if ( !iInitializing ) + { + C_TRACE( ( _T( "RIscApi::Open mutex creation" ) ) ); + TInt createErr( iscapiMutex.CreateGlobal( _L( "ISCAPICONNECT" ) ) ); + if ( createErr == KErrNoMemory ) + { + C_TRACE( ( _T( "RIscApi::Open mutex creation FAILED" ) ) ); + TRequestStatus* ptrStatus = &aStatus; + User::RequestComplete( ptrStatus, KErrNoMemory ); + return; + } + else if ( createErr ) + { + TInt openErr( iscapiMutex.OpenGlobal( _L( "ISCAPICONNECT" ) ) ); + if ( openErr ) + { + C_TRACE( ( _T( "RIscApi::Open mutex open FAILED" ) ) ); + TRequestStatus* ptrStatus = &aStatus; + User::RequestComplete( ptrStatus, KErrNoMemory ); + return; + } + else + { + // Do nothing. + } + } + else + { + // Do nothing. + } + iscapiMutex.Wait(); + } + + RDevice handle; + // If already openend, initialization not needed + TInt r = handle.Open( KIscDriverName ); + if( r == KErrNotFound && !iInitializing ) + { + RIscApi temp; + TRequestStatus status; + temp.InitializeModemInterface( status ); + iInitializing = EFalse; + + User::WaitForRequest( status ); + r = status.Int(); + + temp.Close(); + } + else + { + // Do nothing. + } + + if( !iInitializing ) + { + iscapiMutex.Signal(); + } + else + { + // Do nothing. + } + + if( r != KErrNone ) + { + C_TRACE( ( _T( "RIscApi::Open Initialization FAILED" ) ) ); + TRequestStatus* ptrStatus = &aStatus; + User::RequestComplete( ptrStatus, r ); + return; + } + else + { + // Do nothing. + } +#endif + + TBuf8 info; + TInt error( KErrInUse ); + if( !iOpen ) + { + // handle channels 1 .. 31, open channel to IscDriver + if ( aChannelNumber >= KIscFirstChannel + && aChannelNumber < KIscMaxChannelsInLdd ) + { + C_TRACE( ( _T( "RIscApi::Open 1st ldd" ) ) ); + info.Append( ( TUint8 )aChannelNumber ); + error = DoCreate( KIscDriverName, + TVersion( KMajor, KMinor, KBuild ), + ( TInt )aChannelNumber, + NULL, + &info, + aType ); + + } + // handle channels 32 .. 63, open channel to IscDriverExtension + else if ( aChannelNumber >= KIscMaxChannelsInLdd + && aChannelNumber < KIscNumberOfUnits ) + { + C_TRACE( ( _T( "RIscApi::Open 2nd ldd" ) ) ); + info.Append( ( TUint8 )aChannelNumber ); + TInt channelCount( aChannelNumber - KIscMaxChannelsInLdd ); + error = DoCreate( KIscDriverExtensionName, + TVersion( KMajor, KMinor, KBuild ), + channelCount, + NULL, + &info, + aType ); + } + // channel number out of range + else // illegal channel number + { + User::Panic( KIscApiPanic,EIscApiChannelNumberOutOfRange ); + } + } + + if ( error != KErrNone ) + { + C_TRACE( ( _T( "RIscApi::Open - Channel open Failed,\ + channel 0x%x error %d" ), aChannelNumber, error ) ); + TRequestStatus* ptrStatus = &aStatus; + User::RequestComplete( ptrStatus, error ); + } + else + { + iChannelNumber = aChannelNumber; + C_TRACE( ( _T( "RIscApi::Open iChannelNumber %d " ), iChannelNumber ) ); + iOpen = ETrue; + TAny* params[ KThreeParams ]; + params[ KFirstParam ] = (TAny*)&aStatus; + params[ KSecondParam ] = (TAny*)aChannelNumber; + params[ KThirdParam ] = (TAny*)aOpenParams; + + aStatus = KRequestPending; + error = DoSvControl( EIscAsyncOpen, params ); + } + + A_TRACE( ( _T( "RIscApi::Open - return void" ) ) ); + } + +// ----------------------------------------------------------------------------- +// RIscApi::OpenCancel +// Cancel asynchronous channel opening +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::OpenCancel() + { + A_TRACE( ( _T( "RIscApi::OpenCancel() channel 0x%x" ), iChannelNumber ) ); + + PanicIfNotOpen(); + + DoSvControl( EIscCancelAsyncOpen ); + Close(); + + A_TRACE( ( _T( "RIscApi::OpenCancel - return void" ) ) ); + } + +// ----------------------------------------------------------------------------- +// RIscApi::Close +// Close ISC Channel +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::Close() + { + A_TRACE( ( _T( "RIscApi::Close channel 0x%x" ), iChannelNumber ) ); + + if( iChannelNumber <= KIscLastChannel && iOpen ) + { + DoSvControl( EIscSyncClose ); + } + else + { + // Do nothing. + } + + iChannelNumber = KIscFrameReceiverNotFound; + iOpen = EFalse; + RHandleBase::Close(); + + A_TRACE( ( _T( "RIscApi::Close - return void" ) ) ); + } + +// ----------------------------------------------------------------------------- +// RIscApi::Close +// Close ISC Channel +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::Close( TRequestStatus& aStatus ) + { + A_TRACE( ( _T( "RIscApi::Close(0x%x) channel (0x%x)" ), &aStatus, + iChannelNumber ) ); + + TAny* params[ KOneParam ]; + + params[ KFirstParam ] = (TAny*)&aStatus; + aStatus = KRequestPending; + if ( iChannelNumber <= KIscLastChannel && + iOpen ) + { + DoSvControl( EIscAsyncClose, params ); + } + else + { + C_TRACE((_T("RIscApi::Close FAILED"))); + TRequestStatus* ptrStatus = &aStatus; + User::RequestComplete( ptrStatus, KErrNotReady ); + } + + iOpen = EFalse; + + A_TRACE( ( _T( "RIscApi::Close - return void" ) ) ); + } + +// ----------------------------------------------------------------------------- +// RIsaApi::ResetBuffers +// Resets buffers. +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::ResetBuffers() + { + A_TRACE( ( _T( "RIscApi::ResetBuffers() 0x%x" ), iChannelNumber ) ); + + PanicIfNotOpen(); + + DoSvControl( EIscSyncResetBuffers ); + + A_TRACE( ( _T( "RIscApi::ResetBuffers - return void" ) ) ); + } + +// ----------------------------------------------------------------------------- +// RIscApi::Send +// Send data to Domestic OS ( asynchronous ) +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::Send( + TRequestStatus& aStatus, + const TDesC8& aData ) + { + A_TRACE( ( _T( "RIscApi::Send(0x%x, 0x%x) iChannelNumber (0x%x) this %x" ), + &aStatus, &aData, iChannelNumber, this ) ); + + PanicIfNotOpen(); + + TAny* params[ KTwoParams ]; + + params[ KFirstParam ] = (TAny*)&aStatus; + params[ KSecondParam ] = (TAny*)&aData; + + aStatus = KRequestPending; + DoControl( EIscAsyncSend, params ); + + A_TRACE( ( _T( "RIscApi::Send - return void" ) ) ); + } + +// ----------------------------------------------------------------------------- +// RIscApi::Send +// Send data to Domestic OS ( synchronous ) +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RIscApi::Send( + const TDesC8& aData ) + { + A_TRACE( ( _T( "RIscApi::Send(0x%x) iChannelNumber (0x%x) this %x" ), + &aData, iChannelNumber, this ) ); + + + PanicIfNotOpen(); + + TInt error( KErrNone ); + + TAny* params[ KOneParam ]; + params[ KFirstParam ] = (TAny*)&aData; + + error = DoControl( EIscSyncSend, params ); + + A_TRACE( ( _T( "RIscApi::Send - return %d" ), error ) ); + return error; + } + +// ----------------------------------------------------------------------------- +// RIscApi::SendCancel +// Cancel asynchronous Send request +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::SendCancel() + { + A_TRACE( ( _T( "RIscApi::SendCancel(), channel 0x%x" ), iChannelNumber ) ); + + PanicIfNotOpen(); + + DoSvControl( EIscCancelAsyncSend ); + + A_TRACE( ( _T( "RIscApi::SendCancel - return void" ) ) ); + } + +// ----------------------------------------------------------------------------- +// RIscApi::Receive +// Receive data from Domestic OS +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::Receive( + TRequestStatus& aStatus, + TDes8& aData, + TUint16& aNeededBufLen ) + { + A_TRACE( ( _T( "RIscApi::Receive 0x%x, 0x%x, 0x%x iChannelNumber 0x%x this\ + 0x%x" ), &aStatus, &aData, aNeededBufLen, iChannelNumber, this ) ); + + PanicIfNotOpen(); + + TAny* params[ KThreeParams ]; + + iNeededLen.Set( ( TUint8* )&aNeededBufLen, sizeof ( TUint16 ), sizeof ( TUint16 ) ); + + params[ KFirstParam ] = (TAny*)&aStatus; + params[ KSecondParam ] = (TAny*)&aData; + params[ KThirdParam ] = (TAny*)&iNeededLen; + + aStatus = KRequestPending; + DoControl( EIscAsyncReceive, params ); + + A_TRACE( ( _T( "RIscApi::Receive - return void" ) ) ); + } + +// ----------------------------------------------------------------------------- +// RIscApi::ReceiveCancel +// Cancel data receiving from Domestic OS +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::ReceiveCancel() + { + A_TRACE( ( _T( "RIscApi::ReceiveCancel() iChannelNumber (0x%x)" ), + iChannelNumber ) ); + + PanicIfNotOpen(); + + DoControl( EIscCancelAsyncReceive ); + + A_TRACE( ( _T( "RIscApi::ReceiveCancel - return void" ) ) ); + } + +// ----------------------------------------------------------------------------- +// RIscApi::DataReceiveCancel +// Cancel data receiving from Domestic OS +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::DataReceiveCancel() + { + A_TRACE( ( _T( "RIscApi::DataReceiveCancel() channel 0x%x" ), + iChannelNumber ) ); + + PanicIfNotOpen(); + + DoControl( EIscCancelAsyncDataReceive ); + + A_TRACE( ( _T( "RIscApi::DataReceiveCancel - return void" ) ) ); + } + +// ----------------------------------------------------------------------------- +// RIscApi::ConnectionStatus +// Get the current connection status +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RIscApi::ConnectionStatus() + { + A_TRACE( ( _T( "RIscApi::ConnectionStatus() channel 0x%x" ), + iChannelNumber ) ); + + PanicIfNotOpen(); + + TInt state( EIscConnectionOk ); + + state = DoControl( EIscSyncGetConnectionStatus ); + + A_TRACE( ( _T( "RIscApi::ConnectionStatus - return 0x%x" ), state ) ); + + return state; + } + +// ----------------------------------------------------------------------------- +// RIscApi::NotifyConnectionStatus +// Listen for connection status changes +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::NotifyConnectionStatus( + TRequestStatus& aStatus, + TInt& aConnectionStatus ) + { + A_TRACE( ( _T( "RIscApi::NotifyConnectionStatus(0x%x, 0x%x)\ + iChannelNumber (0x%x)" ), &aStatus, aConnectionStatus, iChannelNumber ) ); + + PanicIfNotOpen(); + + TAny* params[ KTwoParams ]; + + iConnectionStatus.Set( ( TUint8* )&aConnectionStatus, + sizeof ( TInt ), sizeof ( TInt ) ); + + params[ KFirstParam ] = (TAny*)&aStatus; + params[ KSecondParam ] = (TAny*)&iConnectionStatus; + + aStatus = KRequestPending; + DoControl( EIscAsyncNotifyConnectionStatus, params ); + + A_TRACE( ( _T( "RIscApi::NotifyConnectionStatus - return void" ) ) ); + } + +// ----------------------------------------------------------------------------- +// RIscApi::NotifyConnectionStatusCancel +// Stop listening for connection status changes +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::NotifyConnectionStatusCancel() + { + A_TRACE( ( _T( "RIscApi::NotifyConnectionStatusCancel() channel 0x%x" ), + iChannelNumber ) ); + + PanicIfNotOpen(); + + DoControl( EIscCancelAsyncNotifyConnection ); + + A_TRACE( ( _T( "RIscApi::NotifyConnectionStatusCancel - return void" ) ) ); + } + + +// ----------------------------------------------------------------------------- +// RIscApi::CustomFunction +// Asynchronous API extension function +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::CustomFunction( + TRequestStatus& aStatus, + const TUint16 aOperation, + TAny* aParameters ) + { + A_TRACE( ( _T( "RIscApi::CustomFunction(0x%x, 0x%x, 0x%x) iChannelNumber\ + 0x%x" ), &aStatus, aOperation, aParameters, iChannelNumber ) ); + + PanicIfNotOpen(); + + // Check if custom operation is out of range. + if ( aOperation < EIscAsyncCustomOperation1 + || aOperation > EIscAsyncCustomOperation5 ) + { + User::Panic( KIscApiPanic, EIscApiCustomFunctionUndefined ); + } + TAny* params[ KTwoParams ]; + + params[ KFirstParam ] = (TAny*)&aStatus; + params[ KSecondParam ] = aParameters; + + aStatus = KRequestPending; + DoSvControl( aOperation, params ); + + A_TRACE( ( _T( "RIscApi::CustomFunction - return void" ) ) ); + } + +// ----------------------------------------------------------------------------- +// RIscApi::CustomFunction +// Synchronous API extension function +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RIscApi::CustomFunction( + const TUint16 aOperation, + TAny* aParameters ) + { + A_TRACE( ( _T( "RIscApi::CustomFunction(0x%x, 0x%x) iChannelNumber\ + (0x%x) this %x" ), aOperation, aParameters, iChannelNumber, this ) ); + + PanicIfNotOpen(); + + // Check if custom operation is out of range. + if ( aOperation < EIscSyncCustomOperation1 + || aOperation > EIscSyncCustomOperation5 ) + { + User::Panic( KIscApiPanic, EIscApiCustomFunctionUndefined ); + } + + TInt error( KErrNone ); + TAny* params[ KOneParam ]; + params[ KFirstParam ] = aParameters; + + error = DoSvControl( aOperation, params ); + + A_TRACE( ( _T( "RIscApi::CustomFunction - return %d" ), error ) ); + return error; + } + +// ----------------------------------------------------------------------------- +// RIscApi::CustomFunctionCancel +// Cancel the execution of the asynchronous API extension function +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::CustomFunctionCancel( + const TUint16 aOperation ) + { + A_TRACE( ( _T( "RIscApi::CustomFunctionCancel(0x%x) iChannelNumber (0x%x)" ) + , aOperation, iChannelNumber ) ); + + PanicIfNotOpen(); + + // Check if custom operation is out of range + if ( aOperation < EIscCancelAsyncCustomOperation1 + || aOperation > EIscCancelAsyncCustomOperation5 ) + { + User::Panic( KIscApiPanic, EIscApiCustomFunctionUndefined ); + } + + DoSvControl( aOperation ); + + A_TRACE( ( _T( "RIscApi::CustomFunctionCancel - return void" ) ) ); + } + +// ----------------------------------------------------------------------------- +// RIscApi::DataSend +// Send data to Domestic OS ( asynchronous ) +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::DataSend( + TRequestStatus& aStatus, + const TDesC8& aData ) + { + A_TRACE( ( _T( "RIscApi::DataSend(0x%x, 0x%x) iChannelNumber 0x%x" ), + &aStatus, &aData, iChannelNumber ) ); + + PanicIfNotOpen(); + + TAny* params[ KTwoParams ]; + + params[ KFirstParam ] = (TAny*)&aStatus; + params[ KSecondParam ] = (TAny*)&aData; + + aStatus = KRequestPending; + DoControl( EIscAsyncDataSend, params ); + + A_TRACE( ( _T( "RIscApi::DataSend - return void" ) ) ); + } + +// ----------------------------------------------------------------------------- +// RIscApi::DataSend +// Send data to Domestic OS ( synchronous ) +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RIscApi::DataSend( + const TDesC8& aData ) + { + A_TRACE( ( _T( "RIscApi::DataSend(0x%x) iChannelNumber 0x%x" ), + &aData, iChannelNumber ) ); + + PanicIfNotOpen(); + + TInt error( KErrNone ); + TAny* params[ KOneParam ]; + + params[ KFirstParam ] = (TAny*)&aData; + + error = DoControl( EIscSyncDataSend, params ); + + A_TRACE( ( _T( "RIscApi::DataSend - return %d" ), error ) ); + return error; + } + +// ----------------------------------------------------------------------------- +// RIscApi::DataSendCancel +// Cancel asynchronous DataSend request +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::DataSendCancel() + { + A_TRACE( ( _T( "RIscApi::DataSendCancel() iChannelNumber 0x%x" ), + iChannelNumber ) ); + + PanicIfNotOpen(); + + DoSvControl( EIscCancelAsyncDataSend ); + + A_TRACE( ( _T( "RIscApi::DataSendCancel - return void" ) ) ); + } + +// ----------------------------------------------------------------------------- +// RIscApi::DataReceive +// Receive data from Domestic OS +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::DataReceive( + TRequestStatus& aStatus, + TDes8& aData, + TUint16& aNeededBufLen ) + { + A_TRACE( ( _T( "RIscApi::DataReceive(0x%x, 0x%x, 0x%x) iChannelNumber 0x%x" ), + &aStatus, &aData, aNeededBufLen, iChannelNumber ) ); + + PanicIfNotOpen(); + + TAny* params[ KThreeParams ]; + + iNeededDataLen.Set( ( TUint8* )&aNeededBufLen, sizeof ( TUint16 ),sizeof ( TUint16 ) ); + + params[ KFirstParam ] = (TAny*)&aStatus; + params[ KSecondParam ] = (TAny*)&aData; + params[ KThirdParam ] = (TAny*)&iNeededDataLen; + + aStatus = KRequestPending; + DoControl( EIscAsyncDataReceive, params ); + + A_TRACE( ( _T( "RIscApi::DataReceive - return void" ) ) ); + } + +// ----------------------------------------------------------------------------- +// RIscApi::FlowControlStatus +// Get the current flow control status ( in uplink-direction ) +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RIscApi::FlowControlStatus() + { + A_TRACE( ( _T( "RIscApi::FlowControlStatus() channel 0x%x" ), + iChannelNumber ) ); + + PanicIfNotOpen(); + + TInt state( EIscFlowControlOff ); + + state = DoControl( EIscSyncGetFlowControlStatus ); + + A_TRACE( ( _T( "RIscApi::FlowControlStatus - return %d" ), state ) ); + + return state; + } + + +// ----------------------------------------------------------------------------- +// RIscApi::NotifyFlowControl +// Listen for flow control status changes +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::NotifyFlowControl( + TRequestStatus& aStatus, + TInt& aFlowControlStatus ) + { + A_TRACE( ( _T( "RIscApi::NotifyFlowControl(0x%x, 0x%x) channel 0x%x" ), + &aStatus, aFlowControlStatus, iChannelNumber ) ); + + PanicIfNotOpen(); + + TAny* params[ KTwoParams ]; + + iFlowControlStatus.Set( ( TUint8* )&aFlowControlStatus,sizeof ( TInt ),sizeof ( TInt ) ); + + params[ KFirstParam ] = (TAny*)&aStatus; + params[ KSecondParam ] = (TAny*)&iFlowControlStatus; + + aStatus = KRequestPending; + DoControl( EIscAsyncNotifyFlowControlStatus, params ); + + A_TRACE( ( _T( "RIscApi::NotifyFlowControl - return void" ) ) ); + } + + +// ----------------------------------------------------------------------------- +// RIscApi::NotifyFlowControlCancel +// Stop listening for flow control status changes +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C void RIscApi::NotifyFlowControlCancel() + { + A_TRACE( ( _T( "RIscApi::NotifyFlowControlCancel()" ) ) ); + + PanicIfNotOpen(); + + DoControl( EIscCancelAsyncNotifyFlowControl ); + + A_TRACE( ( _T( "RIscApi::NotifyFlowControlCancel - return void" ) ) ); + } + +// ----------------------------------------------------------------------------- +// RIscApi::MaximumDataSize +// Get maximun data size ( for sending and receiving ) +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RIscApi::MaximumDataSize() + { + A_TRACE( ( _T( "RIscApi::MaximumDataSize() channel 0x%x" ), + iChannelNumber ) ); + + PanicIfNotOpen(); + + TInt r = DoControl( EIscSyncGetMaximunDataSize ); + A_TRACE( ( _T( "RIscApi::MaximumDataSize - return 0x%x" ), r ) ); + return r; + + } + +// ----------------------------------------------------------------------------- +// RIscApi::GetChannelInfo +// Get channel info from multiplexer +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RIscApi::GetChannelInfo( + const TUint16 aChannel, + TDes8& aInfo ) + { + A_TRACE( ( _T( "RIscApi::GetChannelInfo(0x%x, 0x%x)" ), + aChannel, &aInfo ) ); + + PanicIfNotOpen(); + + TAny* params[ KTwoParams ]; + params[ KFirstParam ] = (TAny*)aChannel; + params[ KSecondParam ] = (TAny*)&aInfo; + + TInt error = DoControl( EIscSyncGetChannelInfo, params ); + + A_TRACE( ( _T( "RIscApi::GetChannelInfo - return %d" ), error ) ); + return error; + } + +// ----------------------------------------------------------------------------- +// IscApi::PanicIfNotOpen +// Panic if channel is not opened yet +// ( other items were commented in a header ). +// ----------------------------------------------------------------------------- +// +void RIscApi::PanicIfNotOpen() const + { + + if( !iOpen ) + { + C_TRACE( ( _T( "IscApi::PanicIfNotOpen() channel 0x%x" ), + iChannelNumber ) ); + User::Panic( KIscApiPanic, EIscApiChannelNotOpen ); + } + else + { + // Do nothing. + } + } + +// End of File