systemswstubs/examplecommonisc/IscApi/src/IscApi.cpp
changeset 0 0ce1b5ce9557
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/systemswstubs/examplecommonisc/IscApi/src/IscApi.cpp	Thu Jan 14 07:14:53 2010 +0200
@@ -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 <E32svr.H>
+#include <f32file.h>
+#include <iscapi.h>
+#include <IscDefinitions.h>
+#include <iscdefinitions.h>
+#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<TUint16>( channel );
+    iOpen = ETrue;
+
+    TPtrC8 multiplexerInitString( multiplexerInit->Des() );
+    TPtrC8 dataTransmissionInitString( dataTransmissionInit->Des() );
+    TAny* params[ KThreeParams ];
+    params[ KFirstParam ] = (TAny*)&aStatus;
+    params[ KSecondParam ] = static_cast<TAny*>( &multiplexerInitString );
+    params[ KThirdParam ] = static_cast<TAny*>( &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<HBufC8*>( &const_cast<TDesC8&>( 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<KInfoLength> 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