/*

* 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:  An example implementation for ISC Driver Reference

*

*/

// INCLUDE FILES

#include <kern_priv.h>

#include <IscDataTransmissionBase.h>

#include "IscChannel.h"

#include "IscDevice.h"

#include "IscChannelContainer.h"

#include "IscQueue.h"

#include "IscTrace.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

_LIT( KIscDriver, "IscDriver" );

// MACROS

// LOCAL CONSTANTS AND MACROS

const TInt KIscInitializeDfcPriority( 1 );

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 KMultiplyByOne( KSecondParam );

const TInt KMultiplyByThree( KThreeParams );

const TInt KDivideByFour( 4 );

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================ MEMBER FUNCTIONS ===============================

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

// DIscChannel::DIscChannel

// C++ default constructor.

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

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

//

EXPORT_C DIscChannel::DIscChannel( DLogicalDevice* aDevice ) 

    : iInitializeDfc( NULL ),

    iDataTransmissionIniData( NULL ),

    iMultiplexerIniData( NULL ),

    iMultiplexerBuffer( NULL ),

    iDataTransmissionBuffer( NULL ),

    iIscDevice( NULL ),

    iIscConnectionStatusPtr( NULL ),

    iIscFlowControlStatusPtr( NULL ),

    iReceiveBufPtr( NULL ),

    iDataReceiveBufPtr( NULL ),

    iNeededBufLen( NULL ),

    iNeededDataBufLen( NULL ),

    iChannelNumber( 0 ),

    iChannelOpen( EFalse ),

    iFrameRx( NULL ),

    iFrameRxQueue( NULL ),    

    iDataFrameRx( NULL ),

    iDataFrameRxQueue( NULL ),

    iULFlowControlStatus( EIscFlowControlOff ),

    iDLFlowControlStatus( EIscFlowControlOff ),

    iLastNotifiedULFlowstatus( EIscFlowControlOff ),

    iIscChannelHighWaterMark( 0 ),

    iIscChannelLowWaterMark( 0 ),

    iOverFlow( EFalse ),

    iClientPanic( EFalse ),

    iDataTransmissionErrorCode( KErrNone )

    {

    iIscDevice = ( DIscDevice * )aDevice;

    for ( TInt i( KErrNone ); i < EIscAsyncLast; i++ )

        {

        iIscRequests[i] = NULL;

        }

    iThread = &Kern::CurrentThread();   

    TInt r = iThread->Open();

    TRACE_ASSERT( r == KErrNone );

    }

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

// DIscChannel::~DIscChannel

// Destructor

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

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

//

DIscChannel::~DIscChannel()

    {

    C_TRACE( ( _T( "DIscChannel::~DIscChannel()" ) ) );

    if ( iChannelNumber < KIscNumberOfUnits )

        {

        IscChannelContainer::RemoveChannel( this );

        }

    else 

        {

        C_TRACE( ( _T( "DIscChannel::~DIscChannel() re-open" ) ) );

        }

    ChannelDestruction();    

    Kern::SafeClose( ( DObject*& )iThread, NULL );

    C_TRACE( ( _T( "DIscChannel::~DIscChannel() SafeClose called" ) ) );

    }

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

// DIscChannel::ChannelDestruction

// Destructor

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

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

//

void DIscChannel::ChannelDestruction()

    {

    C_TRACE( ( _T( "DIscChannel::ChannelDestruction() iChannelNumber (0x%x)" ),iChannelNumber ) );

    // call DIscMultiplexerBase::CloseDLC and DLFlowControlNotify in case the channel has not been

    // properly closed ( e.g. client thread panic etc. )

    if ( iChannelOpen )

        {

        iIscDevice->CancelSending( iChannelNumber, this );// Delete pending send frames

        iIscDevice->iIscMultiplexerInterface->CloseDLC( iChannelNumber, this );

        iIscDevice->DLFlowControlNotify( EIscFlowControlOff, iChannelNumber, this );

        }

    if ( iFrameRxQueue )

        {

        while ( !iFrameRxQueue->Empty() )

            {

            TDes8* tempPtr = ( TDes8* ) iFrameRxQueue->GetFirst();

            iFrameRxQueue->DeleteFirst();

            iIscDevice->ReleaseMemoryBlock( tempPtr );

            }

        delete iFrameRxQueue;

        iFrameRxQueue = NULL;

        }

    if ( iFrameRx )

            {

            delete [] iFrameRx;

            iFrameRx = NULL;

            }

    if ( iDataFrameRxQueue )

        {

        while ( !iDataFrameRxQueue->Empty() )

            {

            TDes8* tempPtr = ( TDes8* ) iDataFrameRxQueue->GetFirst();

            iDataFrameRxQueue->DeleteFirst();

            iIscDevice->ReleaseMemoryBlock( tempPtr );        

            }

        delete iDataFrameRxQueue;

        iDataFrameRxQueue = NULL;        

        }

    if ( iDataFrameRx )

            {

            delete [] iDataFrameRx;

            iDataFrameRx = NULL;

            }

    if ( iInitializeDfc )

        {        

        delete iInitializeDfc;

        iInitializeDfc = NULL;

        }    

    if ( iDataTransmissionIniData )

        {

        Kern::Free( iDataTransmissionBuffer );

        delete iDataTransmissionIniData;

        iDataTransmissionIniData = NULL;

        }

    if ( iMultiplexerIniData )

        {

        Kern::Free( iMultiplexerBuffer );

        delete iMultiplexerIniData;

        iMultiplexerIniData = NULL;

        }

    C_TRACE( ( _T( "DIscChannel::ChannelDestruction - return void" ) ) );

    }

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

// DIscChannel::HandleMsg

// Message handling ( kernel server context ).

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

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

//

void DIscChannel::HandleMsg( 

    TMessageBase* aMsg )

    {

    C_TRACE( ( _T( "DIscChannel::HandleMsg(0x%x)" ), aMsg ) );

    TThreadMessage& m=*( TThreadMessage* )aMsg;

    TInt id( m.iValue );

    if ( id==( TInt )ECloseMsg )

        {

        C_TRACE( ( _T( "DIscChannel::HandleMsg ECloseMsg" ) ) );

        m.Complete( KErrNone,EFalse );

        return;

        }

    else if ( id==KMaxTInt )

        {

        // DoCancel

        // Should not come here ever

        ASSERT_RESET_ALWAYS( 0,"IscDriver",EIscNotAllowedCallToDoCancel );

        }

    else if ( id<0 )

        {

        // DoRequest

        // should not come here ever

        ASSERT_RESET_ALWAYS( 0,"IscDriver",EIscNotAllowedCallToDoRequest );

        }

    else

        {

        // DoControl

        TUint32 a1[ KThreeParams ];

        TInt r( KErrNone );

        if ( id != EIscSyncClose )

            {

            TInt amountOfParams( KErrNone );

            switch( id )

                {

                case EIscAsyncInitializeModemInterface:

                case EIscAsyncOpen:

                    amountOfParams = KThreeParams;

                    break;

                default:

                    ASSERT_RESET_ALWAYS( 0, "NokiaISCDriver", EIscUnknownCommand );

                break;

                }

            r = Kern::ThreadRawRead( iThread, ( TAny* )m.Ptr0(), a1,

                                     amountOfParams * sizeof( TAny* ) );

            TRACE_ASSERT( r == KErrNone );

            }

        if( r == KErrNone )

            {

            r=HandleRequest( id,a1,m.Ptr1() );

            }

        m.Complete( r,ETrue );

        }

    }

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

// DIscChannel::Request

// Message handling ( user thread context ).

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

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

//

#ifndef COMPONENT_TRACE_FLAG

TInt DIscChannel::Request( TInt aReqNo, TAny* a1, TAny* )

#else 

TInt DIscChannel::Request( TInt aReqNo, TAny* a1, TAny* a2)

#endif

    {

    C_TRACE( ( _T( "DIscChannel::Request(0x%x, 0x%x, 0x%x)" ), aReqNo, a1, a2 ) );

    TInt r( KErrNotFound );

    if ( aReqNo<( TInt )EMinRequestId )

        C_TRACE( ( _T( "DIscChannel::Request ERROR: False aReqNo %d" ), aReqNo ) );

    if ( aReqNo >= 0 && aReqNo < EIscAsyncLastKernelServerContext ||

         aReqNo >= EIscAsyncLast && aReqNo < EIscSyncLastKernelServerContext )

        {

        TThreadMessage& m=Kern::Message();

        m.iValue=aReqNo;

        m.iArg[ KFirstParam ]=a1;

        m.iArg[ KSecondParam ]=NULL;

        r = m.SendReceive( &iMsgQ );

        }

    else

        {

        TInt ulen( KErrNotFound );

        switch ( aReqNo )

            {

            case EIscCancelAsyncInitialize:

            case EIscCancelAsyncReceive:

            case EIscCancelAsyncDataReceive:

            case EIscSyncGetConnectionStatus:

            case EIscCancelAsyncNotifyConnection:

            case EIscSyncGetFlowControlStatus:

            case EIscCancelAsyncNotifyFlowControl:

            case EIscSyncGetMaximunDataSize:

            case EIscCancelAsyncCustomOperation1:

            case EIscCancelAsyncCustomOperation2:

            case EIscCancelAsyncCustomOperation3:

            case EIscCancelAsyncCustomOperation4:

            case EIscCancelAsyncCustomOperation5:

            case EIscCancelAsyncOpen:

            case EIscSyncResetBuffers:

            case EIscCancelAsyncSend:

            case EIscCancelAsyncDataSend:

                {

                ulen = KErrNone;

                break;

                }

            case EIscSyncSend:

            case EIscSyncDataSend:

            case EIscSyncCustomOperation1:

            case EIscSyncCustomOperation2:

            case EIscSyncCustomOperation3:

            case EIscSyncCustomOperation4:

            case EIscSyncCustomOperation5:

            case EIscAsyncClose:

                {

                ulen = KOneParam;

                break;

                }

            case EIscAsyncSend:

            case EIscAsyncDataSend:

            case EIscSyncGetChannelInfo:

            case EIscAsyncNotifyConnectionStatus:

            case EIscAsyncNotifyFlowControlStatus:

            case EIscAsyncCustomOperation1:

            case EIscAsyncCustomOperation2:

            case EIscAsyncCustomOperation3:

            case EIscAsyncCustomOperation4:

            case EIscAsyncCustomOperation5:

                {

                ulen = KTwoParams;

                break;

                }

            case EIscAsyncReceive:

            case EIscAsyncDataReceive:

                {

                ulen = KThreeParams;

                break;

                }

            default:

                {

                TRACE_ASSERT_ALWAYS;

                }

            }

        ASSERT_RESET_ALWAYS( KErrNotFound != ulen, "ISCDriver", EIscUnknownCommand );

        // Maximum number of elements is three!!!

        TAny* kptr[ KThreeParams ] = { KErrNone }; 

        if( ulen > KErrNone )

            {

            C_TRACE( ( _T( "DIscChannel::Request ISC kumemget32" ) ) );

            kumemget32( kptr , a1, ( sizeof( TAny* ) ) * ulen ); 

            }

        r = HandleRequest( aReqNo, kptr, NULL );

        }

    C_TRACE( ( _T( "DIscChannel::Request ISC return %d CH 0x%x" ), r, iChannelNumber ) );

    return r;        

    }

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

// DIscChannel::DoControl

// Handles requests.

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

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

//

TInt DIscChannel::HandleRequest( 

    TInt aFunction, 

    TAny* a1, 

    TAny* /*a2*/ )

    {

    C_TRACE( ( _T( "DIscChannel::DoControl(0x%x, 0x%x) iChannelNumber 0x%x channelPtr 0x%x" ), aFunction, a1, iChannelNumber, this ) );

    TInt error( KErrNone );

#ifdef _DEBUG

    // Check if control frame buffer overflow -> panic

    if ( iClientPanic )

        {

        C_TRACE( ( _T( "DIscChannel::DoControl() BUFFER OVERFLOW: PANIC CLIENT 0x%x" ), iChannelNumber ) );

        TRACE_ASSERT_ALWAYS;

        // This panic the user thread only.

		Kern::ThreadKill( iThread, EExitPanic, EIscControlBufferOverflow, KIscDriver );

        }

#endif // _DEBUG

    // Handle asynchronous requests

    if ( aFunction >= EIscAsyncInitializeModemInterface &&

         aFunction < EIscAsyncLast )

        {

        // if request is already active

        if ( iIscRequests[aFunction] )

            {

            TUint32* tablePtr = ( TUint32* )a1;

            TRequestStatus* requestStatus = ( TRequestStatus* )( tablePtr[ KFirstParam ] );

            Kern::RequestComplete( iThread, requestStatus, KErrAlreadyExists );

            }

        else

            {

            HandleAsyncRequest( aFunction, a1 );

            }

        }

    // Handle synchronous requests.

    else if ( aFunction >= EIscAsyncLast &&

              aFunction < EIscSyncLast )

        {

        error = HandleSyncRequest( aFunction, a1 );

        }

    // Handle cancellation requests.

    else if ( aFunction >= EIscSyncLast &&

              aFunction < EIscCancelLast )

        {

        error = HandleCancelRequest( aFunction, a1 );

        }

    // Undefined request, panic current thread. 

    else

        {

        // This panic the user thread only.

		Kern::ThreadKill( iThread, EExitPanic, EIscControlBufferOverflow, KIscDriver );

        }

    C_TRACE( ( _T( "DIscChannel::DoControl - return %d" ), error ) );

    return error;

    }

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

// DIscChannel::HandleAsyncRequests

// Handles asynchronous client requests

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

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

//

void DIscChannel::HandleAsyncRequest( 

    TInt aFunction, 

    TAny* a1 )

    {

    C_TRACE( ( _T( "DIscChannel::HandleAsyncRequest(0x%x, 0x%x) channelPtr 0x%x" ), aFunction, a1, this ) );

    TUint32* tablePtr = ( TUint32* )a1;

    switch ( aFunction )

        {

        case EIscAsyncInitializeModemInterface:

            {    

            TInt r = KErrNotFound;

            iIscRequests[EIscAsyncInitializeModemInterface] = ( TRequestStatus* )( tablePtr[ KFirstParam ] );

            iInitializeDfc = new TDfc( InitializeComplete, this, Kern::DfcQue0(), KIscInitializeDfcPriority );            

            ASSERT_RESET_ALWAYS( iInitializeDfc, "IscDriver",EIscMemoryAllocationFailure );

            // Get Data Transmission Driver initialization string

            TDesC8* tempPtr = ( TDesC8* )tablePtr[ KThirdParam ];

            iDataTransmissionBuffer = ( TUint8* )Kern::Alloc( KIscIniLineLength );

            ASSERT_RESET_ALWAYS( iDataTransmissionBuffer, "IscDriver",EIscMemoryAllocationFailure );

            iDataTransmissionIniData = new ( TPtr8 )( iDataTransmissionBuffer, KIscIniLineLength );

            ASSERT_RESET_ALWAYS( iDataTransmissionIniData, "IscDriver",EIscMemoryAllocationFailure );

            r = Kern::ThreadDesRead( iThread, tempPtr, *iDataTransmissionIniData, 0, KChunkShiftBy0 );

            ASSERT_RESET_ALWAYS( r == KErrNone, "IscDriver",EIscMemoryAllocationFailure );

            // Get Multiplexer initialization string

            tempPtr = ( TDesC8* )tablePtr[1];

            iMultiplexerBuffer = ( TUint8* )Kern::Alloc( KIscIniLineLength );

            ASSERT_RESET_ALWAYS( iMultiplexerBuffer, "IscDriver",EIscMemoryAllocationFailure );

            iMultiplexerIniData = new ( TPtr8 )( iMultiplexerBuffer, KIscIniLineLength );

            ASSERT_RESET_ALWAYS( iDataTransmissionIniData, "IscDriver",EIscMemoryAllocationFailure );

            r = Kern::ThreadDesRead( iThread, tempPtr, *iMultiplexerIniData, 0, KChunkShiftBy0 );

            ASSERT_RESET_ALWAYS( r == KErrNone, "IscDriver",EIscMemoryAllocationFailure );

            // If buffer configuration is given from isc_config.ini as multiplexer configuration string, multiplexer 

            // needs configuration before datatransmissin driver is initialized

            iIscDevice->iIscMultiplexerInterface->SetInitializationParameters( *iMultiplexerIniData );

            // Allocate buffers and receive queues

            iIscDevice->Initialize();

            iIscDevice->iIscDataTransmissionInterface->InitializeDataTransmission( *iDataTransmissionIniData, 

                                                                                   iInitializeDfc,

                                                                                   iDataTransmissionErrorCode );            

            break;

            }

        case EIscAsyncOpen:

            {

            iIscRequests[EIscAsyncOpen] = ( TRequestStatus* )( tablePtr[ KFirstParam ] );

            if ( iIscDevice->ConnectionStatus() == EIscConnectionOk )

                {

                TDesC8* openInfo = ( TDesC8* )tablePtr[ KThirdParam ];

                // Channel info parameter has to be copied from user side in Epoc Kernel Architecture 2

                TInt length = Kern::ThreadGetDesLength( iThread, ( TDesC8* )tablePtr[ KThirdParam ] );

                TUint8* buffer = NULL;

                TPtr8* bufferPtr = NULL;

                if ( length > KErrNone )

                    {

                    C_TRACE( ( _T( "DIscChannel::HandleAsyncRequest EIscAsyncOpen channel info got" ) ) );

                    buffer = ( TUint8* )Kern::Alloc( length );

                    bufferPtr = new ( TPtr8 )( buffer, length );

                    TInt r = Kern::ThreadDesRead( iThread, openInfo, *bufferPtr, 0, KChunkShiftBy0 );

                    ASSERT_RESET_ALWAYS( r == KErrNone, "IscDriver",EIscMemoryAllocationFailure );

                    openInfo = ( TDesC8* )bufferPtr;

                    }

                iIscDevice->iIscMultiplexerInterface->OpenDLC( ( TUint16 )tablePtr[ KSecondParam ], 

                                                               openInfo,

                                                               this );