/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

* 

* Description: 

*

*/

/*****************************************************************************

   R&D NOTES ARE:

   TODO:     Something needs to be done

   TBR:        Something could be removed between TBR's

*****************************************************************************/

// INCLUDE FILES

#include <iscapi.h>                 // For RIscApi

#include "iaduserapitrace.h"        // For C_TRACE...

#include "iadinternaldefinitions.h" // For EIAD

#include "iadnokiadefinitions.h"    // For EIADCustom

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "isaapiTraces.h"

#endif

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

const TUint8 KOneParam( 1 );

const TUint8 KTwoParams( 2 );

const TUint8 KThreeParams( 3 );

const TUint8 KFirstParam( 0 );

const TUint8 KSecondParam( 1 );

const TUint8 KThirdParam( 2 );

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, 0 ),

     iNeededDataLen( NULL, 0 ),

     iConnectionStatus( NULL, 0 ),

     iFlowControlStatus( NULL, 0 ),

     iOpen( EFalse ),

     iChannelNumber( KNotInitializedChannel )

    {

    OstTrace0( TRACE_NORMAL, RISCAPI_RISCAPI_ENTRY, "<>RIscApi::RIscApi" );

    C_TRACE( ( _T( "RIscApi::RIscApi <->" ) ) );

    }

EXPORT_C RIscApi::~RIscApi()

    {

    OstTraceExt1( TRACE_NORMAL, DUP1_RISCAPI_RISCAPI_ENTRY, ">RIscApi::~RIscApi;iChannelNumber=%hx", iChannelNumber );

    C_TRACE( ( _T( "RIscApi::~RIscApi 0x%x ->" ), iChannelNumber ) );

    Close();

    C_TRACE( ( _T( "RIscApi::~RIscApi 0x%x <-" ), iChannelNumber ) );

    OstTrace0( TRACE_NORMAL, DUP1_RISCAPI_RISCAPI_EXIT, "<RIscApi::~RIscApi" );

    }

// -----------------------------------------------------------------------------

// RIscApi::Initialize

// Initialize the ISC Interface

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

EXPORT_C void RIscApi::InitializeModemInterface(

        TRequestStatus& aStatus

        )

    {

    OstTraceExt2( TRACE_NORMAL, RISCAPI_INITIALIZEMODEMINTERFACE_ENTRY, ">RIscApi::InitializeModemInterface;aStatus=%x;iChannelNumber=%hx", ( TUint )&( aStatus ), iChannelNumber );

    C_TRACE( ( _T( "RIscApi::InitializeModemInterface 0x%x 0x%x ->" ), iChannelNumber, &aStatus ) );

    TRACE_ASSERT_ALWAYS;

    TRequestStatus* status = &aStatus;

    User::RequestComplete( status, KErrNone );

    C_TRACE( ( _T( "RIscApi::InitializeModemInterfaceL 0x%x <-" ), iChannelNumber ) );

    OstTrace0( TRACE_NORMAL, RISCAPI_INITIALIZEMODEMINTERFACE_EXIT, "<RIscApi::InitializeModemInterface" );

    }

// -----------------------------------------------------------------------------

// RIscApi::InitializeCancel

// Cancel ISC Initialization sequence

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

EXPORT_C void RIscApi::InitializeCancel(

        // None

        )

    {

    OstTrace0( TRACE_NORMAL, RISCAPI_INITIALIZECANCEL_ENTRY, ">RIscApi::InitializeCancel" );

    C_TRACE( ( _T( "RIscApi::InitializeCancel ->" ) ) );

    TRACE_ASSERT_ALWAYS;

    C_TRACE( ( _T( "RIscApi::InitializeCancel  <-" ) ) );

    OstTrace0( TRACE_NORMAL, RISCAPI_INITIALIZECANCEL_EXIT, "<RIscApi::InitializeCancel" );

    }

// -----------------------------------------------------------------------------

// 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

    {

    OstTrace0( TRACE_NORMAL, RISCAPI_LOADL_ENTRY, ">RIscApi::LoadL" );

    C_TRACE( ( _T( "RIscApi::LoadL ->" ) ) );

    TRACE_ASSERT_ALWAYS;

    C_TRACE( ( _T( "RIscApi::LoadL <-" ) ) );

    OstTrace0( TRACE_NORMAL, RISCAPI_LOADL_EXIT, "<RIscApi::LoadL" );

    }

// -----------------------------------------------------------------------------

// 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

        )

    {

    OstTraceExt4( TRACE_NORMAL, RISCAPI_OPEN_ENTRY, ">RIscApi::Open;aChannelNumber=%hu;aStatus=%x;aType=%x;aOpenParams=%x", aChannelNumber, ( TUint )&( aStatus ), ( TUint )&( aType ), ( TUint )( aOpenParams ) );

    C_TRACE( ( _T( "RIscApi::Open 0x%x, 0x%x, 0x%x, 0x%x this 0x%x ->" ),

                   aChannelNumber, &aStatus, aType, aOpenParams, this ) );

    // Driver is tried to load everytime.

    TInt loadStatus( User::LoadLogicalDevice( KNameOfIsaAccessDriverLdd ) );

    C_TRACE( ( _T( "RIscApi::Open devicedriver loaded %d" ), loadStatus ) );

    ASSERT_PANIC_ALWAYS( ( KErrNone == loadStatus || KErrAlreadyExists == loadStatus), EIADDriverLoadFailed );

    TInt error( KErrInUse );

    if( KNotInitializedChannel == iChannelNumber )

        {

        TBuf8<KInfoLength> info;

        ASSERT_PANIC_ALWAYS( ( aChannelNumber < EIADNokiaLastUserChannel ), EIADChannelNumberOutofRange );

        C_TRACE( ( _T( "RIscApi::Open ldd" ) ) );

        OstTrace0( TRACE_NORMAL, RISCAPI_OPEN, "RIscApi::Open ldd" );        

        info.Append( aChannelNumber );

        error = DoCreate( KIADDriverName, 

                          TVersion(), 

                          KNullUnit, 

                          NULL, 

                          &info, 

                          aType );

        }

    if( KErrNone != error )

        {

        C_TRACE( ( _T( "RIscApi::Open  - failed 0x%x error %d" ), aChannelNumber, error ) );

        OstTraceExt2( TRACE_NORMAL, RISCAPI_OPEN_FAILED, "RIscApi::Open - failed;aChannelNumber=%hx;error=%d", aChannelNumber, error );

        TRequestStatus* ptrStatus = &aStatus;

        User::RequestComplete( ptrStatus, error );

        }

    else

        {

        C_TRACE( ( _T( "RIscApi::Open iChannelNumber %d aChannelNumber %d " ), iChannelNumber, aChannelNumber ) );

        OstTraceExt2( TRACE_NORMAL, DUP1_RISCAPI_OPEN, "RIscApi::Open;iChannelNumber=%hx;aChannelNumber=%hx", iChannelNumber, aChannelNumber );        

        aStatus = KRequestPending;

        TAny* params[ KThreeParams ];

        params[ KSecondParam ] = reinterpret_cast< TAny* >( &iChannelNumber );

        // If opened with resource (aOpenParams).

        params[ KThirdParam ] = reinterpret_cast< TAny* >( const_cast<TDesC8*>( aOpenParams ) );

        error = DoControl( EIADAsyncOpen, params );

        TRACE_ASSERT_ALWAYS_COND( KErrNone == error );

        // In case of KErrAlreadyExists as a result to open we must close the handle after open.

            {

            C_TRACE(  (  _T(  "RIscApi::Open close handle KErrAlreadyExists" ) ) );

            OstTraceExt1( TRACE_NORMAL, RISCAPI_OPEN_ALREADY_EXIST, "RIscApi::Open;aChannelNumber=%hx", aChannelNumber );

            RHandleBase::Close();

            }

        }

    C_TRACE(  (  _T(  "RIscApi::Open <-" ) ) );

    OstTrace0( TRACE_NORMAL, RISCAPI_OPEN_EXIT, "<RIscApi::Open" );

    }

#if (NCP_COMMON_SOS_VERSION_SUPPORT >= SOS_VERSION_95)

EXPORT_C TInt RIscApi::Loan( 

        const TUint16 aChannelNumber,

        TOwnerType aHandleType

        // None

        )

    {

    C_TRACE( ( _T( "RIscApi::Loan 0x%x ->" ), iChannelNumber ) );

    OstTraceExt1( TRACE_NORMAL, RISCAPI_LOAN_ENTRY, ">RIscApi::Loan;iChannelNumber=%hx", iChannelNumber );

    // TODO: panic if open?

    //    PanicIfNotOpen();

    // Driver is tried to load everytime.

    TInt loadStatus( User::LoadLogicalDevice( KNameOfIsaAccessDriverLdd ) );

    C_TRACE( ( _T( "RIscApi::Open devicedriver loaded %d" ), loadStatus ) );

    OstTrace1( TRACE_NORMAL, DUY1_RISCAPI_LOAN, "RIscApi::Loan;loaded=%d", loadStatus );

    ASSERT_PANIC_ALWAYS( ( KErrNone == loadStatus || KErrAlreadyExists == loadStatus), EIADDriverLoadFailed );

    TInt error( KErrInUse );

    if( KNotInitializedChannel == iChannelNumber )

        {

        TBuf8<KInfoLength> info;

        ASSERT_PANIC_ALWAYS( ( aChannelNumber < EIADNokiaLastUserChannel ), EIADChannelNumberOutofRange );

        C_TRACE( ( _T( "RIscApi::Loan ldd" ) ) );

        info.Append( aChannelNumber );

        error = DoCreate( KIADDriverName, 

                          TVersion(), 

                          KNullUnit, 

                          NULL, 

                          &info, 

                          aHandleType );

        }

    if( KErrNone == error )

        {

        C_TRACE( ( _T( "RIscApi::Loan iChannelNumber %d aChannelNumber %d " ), iChannelNumber, aChannelNumber ) );

        OstTraceExt2( TRACE_NORMAL, DUY2_RISCAPI_LOAN, "RIscApi::Loan;iChannelNumber=%d;aChannelNumber=%d", iChannelNumber, aChannelNumber );

        TAny* params[ KOneParam ];

        params[ KFirstParam ] = reinterpret_cast< TAny* >( &iChannelNumber );

        error = DoControl( EIADLoan, params );

        TRACE_ASSERT_ALWAYS_COND( KErrNone == error );

        if( KErrNone != error )

            {

            C_TRACE(  (  _T(  "RIscApi::Loan loan failed. closing the handle.." ) ) );

            OstTrace0( TRACE_NORMAL, DUY3_RISCAPI_LOAN, "RIscApi::Loan loan failed. closing the handle.." );

            RHandleBase::Close();

            }

        }

    TRACE_ASSERT_ALWAYS_COND( KErrNone == error );

    OstTraceExt1( TRACE_NORMAL, RISCAPI_LOAN_EXIT, "<RIscApi::Loan;iChannelNumber=%hx", iChannelNumber );

    C_TRACE( ( _T( "RIscApi::Loan 0x%x %d<-" ), iChannelNumber, error ) );

    return error;

    }

EXPORT_C void RIscApi::ReturnLoan( 

        const TUint16 // aChannelNumber

        // None

        )

    {

    C_TRACE( ( _T( "RIscApi::ReturnLoan 0x%x ->" ), iChannelNumber ) );

    OstTraceExt1( TRACE_NORMAL, RISCAPI_RETURNLOAN_ENTRY, ">RIscApi::Loan;iChannelNumber=%hx", iChannelNumber );

    PanicIfNotOpen();

    if( iChannelNumber < EIADNokiaLastUserChannel )

        {

        TInt ret( DoControl( EIADReturnLoan ) );

        ASSERT_PANIC_ALWAYS( KErrNone == ret, EIADReturnLoan );

        iChannelNumber = KNotInitializedChannel;

        RHandleBase::Close();// Close the channel handle.

        }

    OstTraceExt1( TRACE_NORMAL, RISCAPI_RETURNLOAN_EXIT, "<RIscApi::Loan;iChannelNumber=%hx", iChannelNumber );

    C_TRACE( ( _T( "RIscApi::ReturnLoan 0x%x %d<-" ), iChannelNumber ) );

    }

#endif

// -----------------------------------------------------------------------------

// RIscApi::OpenCancel

// Cancel asynchronous channel opening

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

EXPORT_C void RIscApi::OpenCancel(

        // None

        )

    {

    OstTraceExt1( TRACE_NORMAL, RISCAPI_OPENCANCEL_ENTRY, ">RIscApi::OpenCancel;iChannelNumber=%hx", iChannelNumber );

    C_TRACE( ( _T( "RIscApi::OpenCancel 0x%x ->" ), iChannelNumber ) );

    PanicIfNotOpen();

    DoCancel( EIADAsyncOpen );

    Close();

    C_TRACE( ( _T( "RIscApi::OpenCancel 0x%x <-" ), iChannelNumber ) );

    OstTrace0( TRACE_NORMAL, RISCAPI_OPENCANCEL_EXIT, "<RIscApi::OpenCancel" );

    }

// -----------------------------------------------------------------------------

// RIscApi::Close

// Close ISC Channel

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

EXPORT_C void RIscApi::Close(

        // None

        )

    {

    OstTraceExt1( TRACE_NORMAL, RISCAPI_CLOSE_ENTRY, ">RIscApi::Close;iChannelNumber=%hx", iChannelNumber );

    C_TRACE( ( _T( "RIscApi::Close 0x%x 0x%x ->" ), iChannelNumber, this ) );

    if( iChannelNumber < EIADNokiaLastUserChannel )

        {

        PanicIfNotOpen();

        TInt ret( DoControl( EIADClose ) );

        ASSERT_PANIC_ALWAYS( KErrNone == ret, EIADCloseFailed );

        iChannelNumber = KNotInitializedChannel;

        C_TRACE(  (  _T(  "RIscApi::Close close handle" ) ) );

        OstTrace0( TRACE_NORMAL, RISCAPI_CLOSE, "RIscApi::Close close handle" );        

        RHandleBase::Close();

        }

    else

        {

        C_TRACE((_T("RIscApi::Close error: channel number out of range")));

        OstTrace0( TRACE_NORMAL, DUP1_RISCAPI_CLOSE, "RIscApi::Close channelnumber out of range" );

//        TRACE_ASSERT_ALWAYS;        TODO: Trace assert?

        }

    C_TRACE( ( _T( "RIscApi::Close 0x%x <-" ), iChannelNumber ) );

    OstTrace0( TRACE_NORMAL, RISCAPI_CLOSE_EXIT, "<RIscApi::Close" );

    }

// -----------------------------------------------------------------------------

// RIscApi::Close

// Close ISC Channel

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

EXPORT_C void RIscApi::Close(

        TRequestStatus& aStatus

        )

    {

    OstTraceExt2( TRACE_NORMAL, DUP1_RISCAPI_CLOSE_ENTRY, ">RIscApi::Close;aStatus=%x;iChannelNumber=%hx", ( TUint )&( aStatus ), iChannelNumber );

    C_TRACE( ( _T( "RIscApi::Close 0x%x 0x%x ->" ), iChannelNumber, &aStatus ) );

    if( iChannelNumber < EIADNokiaLastUserChannel )

        {

        PanicIfNotOpen();

        aStatus = KRequestPending;

        TAny* params[ KOneParam ];

        params[ KFirstParam ] = reinterpret_cast< TAny* >( &aStatus );

        TInt ret( DoControl( EIADAsyncClose, params ) );

        ASSERT_PANIC_ALWAYS( KErrNone == ret, EIADCloseFailed );

        iChannelNumber = KNotInitializedChannel;

        C_TRACE(  (  _T(  "RIscApi::Close a close handle" ) ) );

        RHandleBase::Close();// Added handle close

        }

    else

        {

        C_TRACE((_T("RIscApi::Close error: channel number out of range")));

        TRequestStatus* ptrStatus = &aStatus;

        User::RequestComplete( ptrStatus, KErrNotReady );

        }

    C_TRACE( ( _T( "RIscApi::Close 0x%x 0x%x <-" ), iChannelNumber, &aStatus ) );

    OstTrace0( TRACE_NORMAL, DUP1_RISCAPI_CLOSE_EXIT, "<RIscApi::Close" );

    }

// -----------------------------------------------------------------------------

// RIscApi::ResetBuffers

// Resets buffers.

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

EXPORT_C void RIscApi::ResetBuffers(

        // None

        )

    {

    OstTraceExt1( TRACE_NORMAL, RISCAPI_RESETBUFFERS_ENTRY, ">RIscApi::ResetBuffers;iChannelNumber=%hx", iChannelNumber );

    C_TRACE( ( _T( "RIscApi::ResetBuffers 0x%x ->" ), iChannelNumber ) );

    PanicIfNotOpen();

    TRACE_ASSERT_ALWAYS_COND( KErrNone == DoControl( EIADResetQueues ) );

    C_TRACE( ( _T( "RIscApi::ResetBuffers <-" ) ) );

    OstTrace0( TRACE_NORMAL, RISCAPI_RESETBUFFERS_EXIT, "<RIscApi::ResetBuffers"  );

    }

// -----------------------------------------------------------------------------

// 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

        )

    {

    OstTraceExt2( TRACE_NORMAL, RISCAPI_SEND_ENTRY, ">RIscApi::Send;aStatus=%x;aData=%x", ( TUint )&( aStatus ), ( TUint )&( aData ) );

    C_TRACE( ( _T( "RIscApi::Send a 0x%x 0x%x 0x%x this 0x%x ->" ),

                   iChannelNumber, &aStatus, &aData, this ) );

    PanicIfNotOpen();

    TAny* params[ KTwoParams ];

    params[ KFirstParam ] = reinterpret_cast<TAny*>( &aStatus );

    params[ KSecondParam ] = reinterpret_cast<TAny*>( const_cast<TDesC8*>( &aData ));

    aStatus = KRequestPending;

    DoControl( EIADAsyncSend, params );

    C_TRACE( ( _T( "RIscApi::Send <-" )  ) );

    OstTrace0( TRACE_NORMAL, RISCAPI_SEND_EXIT, "<RIscApi::Send" );

    }

// -----------------------------------------------------------------------------

// RIscApi::Send

// Send data to Domestic OS ( synchronous )

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

EXPORT_C TInt RIscApi::Send(

        const TDesC8& aData

        )

    {

    OstTraceExt2( TRACE_NORMAL, DUP1_RISCAPI_SEND_ENTRY, ">RIscApi::Send;aData=%x;iChannelNumber=%hx", ( TUint )&( aData ), iChannelNumber );

    C_TRACE( ( _T( "RIscApi::Send 0x%x 0x%x 0x%x ->" ), iChannelNumber, &aData, this ) );

    PanicIfNotOpen();

    TAny* params[ KOneParam ];

    params[ KFirstParam ] = reinterpret_cast<TAny*>( &( const_cast<TDesC8&>( aData ) ) );

    TInt error( DoControl( EIADSend, params ) );

    C_TRACE( ( _T( "RIscApi::Send 0x%x 0x%x 0x%x %d <-" ), iChannelNumber, &aData, this, error ) );

    OstTrace1( TRACE_NORMAL, DUP1_RISCAPI_SEND_EXIT, "<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(

        // None

        )

    {

    OstTraceExt1( TRACE_NORMAL, RISCAPI_SENDCANCEL_ENTRY, ">RIscApi::SendCancel;iChannelNumber=%hx", iChannelNumber );

    C_TRACE(  (  _T(  "RIscApi::SendCancel 0x%x ->" ), iChannelNumber ) );

    PanicIfNotOpen();

    DoCancel( EIADAsyncSend );

    C_TRACE( ( _T( "RIscApi::SendCancel <-" ) ) );

    OstTrace0( TRACE_NORMAL, RISCAPI_SENDCANCEL_EXIT, "<RIscApi::SendCancel");

    }

// -----------------------------------------------------------------------------

// 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

        )

    {

    OstTraceExt4( TRACE_NORMAL, RISCAPI_RECEIVE_ENTRY, ">RIscApi::Receive;aStatus=%x;aData=%x;aNeededBufLen=%hu;iChannelNumber=%hx", ( TUint )&( aStatus ), ( TUint )&( aData ), aNeededBufLen, iChannelNumber );

    C_TRACE( ( _T( "RIscApi::Receive 0x%x, 0x%x, 0x%x 0x%x this 0x%x ->" ), &aStatus, &aData, aNeededBufLen, iChannelNumber, this ) );

    PanicIfNotOpen();

    TAny* params[ KThreeParams ];

    // Set status pending, just in case client haven't done it.

    aStatus = KRequestPending;

    params[ KFirstParam ] = reinterpret_cast<TAny*>( &aStatus );

    params[ KSecondParam ] = reinterpret_cast<TAny*>( &aData );

    params[ KThirdParam ] = reinterpret_cast<TAny*>( &aNeededBufLen );

    DoControl( EIADAsyncReceive, params );

    C_TRACE( ( _T( "RIscApi::Receive 0x%x this 0x%x <-" ), iChannelNumber, this ) );

    OstTrace0( TRACE_NORMAL, RISCAPI_RECEIVE_EXIT, "<RIscApi::Receive" );

    }

// -----------------------------------------------------------------------------

// RIscApi::ReceiveCancel

// Cancel data receiving from Domestic OS

// ( other items were commented in a header ).

// -----------------------------------------------------------------------------

//

EXPORT_C void RIscApi::ReceiveCancel(

        // None

        )

    {

    OstTraceExt1( TRACE_NORMAL, RISCAPI_RECEIVECANCEL_ENTRY, ">RIscApi::ReceiveCancel;iChannelNumber=%hx", iChannelNumber );

    C_TRACE( ( _T( "RIscApi::ReceiveCancel 0x%x ->"), iChannelNumber ) );

    PanicIfNotOpen();

    DoCancel( EIADAsyncReceive );