/*

* Copyright (c) 2007-2008 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: 

*

*/

// INCLUDE FILES

#include "dpdef.h"        // dataport definitions

#include "dpdataport.h"   // dataport main and c32 interface

#include "dprx2dte.h"     // moves data from rx buffer to client

#include "dpbreak.h"      // break handling

#include "dpflowctrl.h"   // flow control handling

#include "dpdataconfig.h" // configuration store

#include "dptermdetect.h" // terminator detection

#include "dplog.h"        // dataport logging

#ifdef OST_TRACE_COMPILER_IN_USE

#endif

// EXTERNAL DATA STRUCTURES

// none

// EXTERNAL FUNCTION PROTOTYPES

// none

// CONSTANTS

// none

// MACROS

// none

// LOCAL CONSTANTS AND MACROS

// none

// MODULE DATA STRUCTURES

// none

// LOCAL FUNCTION PROTOTYPES

// none

// FORWARD DECLARATIONS

// none

// ============================= LOCAL FUNCTIONS ===============================

// none

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

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

// CDpRx2Dte::CDpRx2Dte

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CDpRx2Dte::CDpRx2Dte (

    CDpDataPort& aDataPort ) :

    CActive( KDpRx2DtePriority ),

    iDataPort( aDataPort ),

    iBufferRx( iDataPort.Rx() ),

    iFlowCtrl( iDataPort.FlowCtrl() ),

    iDataConfig( iDataPort.DataConfig() ),

    iBreak( iDataPort.BreakHandler() ),

    iTermDetect( iDataPort.TermDetect() ),

    iRx( 0, 0 ),

    iRxTail( 0, 0 ),

    iRole( MDpDataClient::EDbDataClientReader )

    {

    OstTrace0( TRACE_NORMAL, CDPRX2DTE_CDPRX2DTE, "CDpRx2Dte::CDpRx2Dte" );

    LOGM("CDpRx2Dte::CDpRx2Dte");

    }

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

// CDpRx2Dte::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CDpRx2Dte::ConstructL()

    {

    OstTrace0( TRACE_NORMAL, CDPRX2DTE_CONSTRUCTL, "CDpRx2Dte::ConstructL" );

    LOGM("CDpRx2Dte::ConstructL");

    // If registering fails => can't do nothing here => must leave

    User::LeaveIfError( iBufferRx.RegisterDataClient( *this ) );

    CActiveScheduler::Add( this );

    if ( !IsActive() )

        {

        iStatus = KRequestPending;

        iRequestActive = ETrue;

        SetActive();

        }

    //no else

    }

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

// CDpRx2Dte::NewL

// Two-phased constructor.

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

//

CDpRx2Dte* CDpRx2Dte::NewL(

    CDpDataPort& aDataPort )

    {

    OstTrace0( TRACE_NORMAL, CDPRX2DTE_NEWL, "CDpRx2Dte::NewL" );

    LOGM("CDpRx2Dte::NewL");

    CDpRx2Dte* self = new (ELeave) CDpRx2Dte( aDataPort );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CDpRx2Dte::~CDpRx2Dte

// Destructor

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

//

CDpRx2Dte::~CDpRx2Dte()

    {

    OstTrace0( TRACE_NORMAL, DUP1_CDPRX2DTE_CDPRX2DTE, "CDpRx2Dte::~CDpRx2Dte" );

    LOGM("CDpRx2Dte::~CDpRx2Dte");

    iClientBuffer = 0;

    }

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

// CDpRx2Dte::RunL

// We are signalled from Pn2Rx or from ourselves (Rx2Dte).

// Always when we are signalled there is data available to be written

// into client space. This method also checks if RX flow control

// 'water mark low' is reached and informs flow control handler about that.

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

//

void CDpRx2Dte::RunL()

    {

    OstTrace0( TRACE_NORMAL, CDPRX2DTE_RUNL, "CDpRx2Dte::RunL" );

    OstTrace1( TRACE_NORMAL, DUP1_CDPRX2DTE_RUNL, "CDpRx2Dte:: Port: %u", iDataPort.PortUnit() );

    LOGM1("CDpRx2Dte::RunL - Port %d", iDataPort.PortUnit() );

    if ( iStatus != KErrCancel )

        {

#ifdef _DEBUG

        TInt ret( KErrNone );

#endif

        if ( 0 < iEchoData.Length() && iReadPending )

            {

            // Writes echo bytes to the client

#ifdef _DEBUG

            ret =

#endif

            WriteEchoToClient();

            }

        else if ( iReadPending )

            {

#ifdef _DEBUG

            ret =

#endif

            WriteIntoClientSpace();

            }

        //no else

#ifdef _DEBUG

        if ( ret != KErrNone )

            {

            LOG(" ERROR, CDpRx2Dte::RunL, Writing echo bytes to the client");

            OstTrace0( TRACE_NORMAL, DUP2_CDPRX2DTE_RUNL, "ERROR, CDpRx2Dte::RunL, Writing echo bytes to the client" );

            }

        //no else

#endif

        if ( !IsActive() )

            {

            iStatus = KRequestPending;

            iRequestActive = ETrue;

            SetActive();

            }

        //no else

        if ( iReadPending &&

            ( 0 < iBufferRx.UsedBytes() || 0 < iEchoData.Length() ) )

            {

            iDataPort.SignalRx2Dte();

            }

        //no else

        }

    //no else

    }

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

// CDpRx2Dte::RunError

// Leave in RunL() is handled here. RunL() should not leave.

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

//

TInt CDpRx2Dte::RunError(

    TInt aError )

    {

    OstTrace0( TRACE_NORMAL, CDPRX2DTE_RUNERROR, "CDpRx2Dte::RunError" );

    OstTraceExt2( TRACE_NORMAL, DUP1_CDPRX2DTE_RUNERROR, "CDpRx2Dte:: Port: %u, error code: %d", iDataPort.PortUnit(), aError );

    LOGM2("CDpRx2Dte::RunError - Port %d, error code: %d",

        iDataPort.PortUnit(), aError );

    return aError;

    }

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

// CDpRx2Dte::DoCancel

// This method cancels this active object

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

//

void CDpRx2Dte::DoCancel()

    {

    OstTrace0( TRACE_NORMAL, CDPRX2DTE_DOCANCEL, "CDpRx2Dte::DoCancel" );

    LOGM("CDpRx2Dte::DoCancel");

    if ( iRequestActive )

        {

        // do the required signaling

        iRequestActive = EFalse;

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrCancel );

        }

    //no else

    }

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

// CDpRx2Dte::SetDteRead

// This is forwarded client StartRead().

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

//

TInt CDpRx2Dte::SetDteRead(

    const TAny* aDes,

    TInt aLength )

    {

    OstTrace0( TRACE_NORMAL, CDPRX2DTE_SETDTEREAD, "CDpRx2Dte::SetDteRead" );

    LOGM("CDpRx2Dte::SetDteRead");

    TInt ret( KErrNone );

    // no pending read

    if ( !iReadPending )

        {

        iReadPending = ETrue;

        // pointer into client buffer

        iClientBuffer = const_cast<TAny*>( aDes );

        iClientRequestedLength = aLength;

        if ( 0 > aLength )

            {

            // ReadOneOrMore

            // C32 gives client buffer size as negative value

            // see ECUART implementation

            iClientBufferLength = -aLength;

            }

        else

            {

            iClientBufferLength = aLength;

            }

        // if there is data ready signal ourselves

        if ( 0 < iBufferRx.UsedBytes() || 0 < iEchoData.Length() )

            {

            iDataPort.SignalRx2Dte();

            }

        //no else

        }

    else

        {

        // read twice attempted

        ret = KErrInUse;

        }

    return ret;

    }

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

// CDpRx2Dte::ResetDteRead

// This is forwarded client made ReadCancel().

// C32 makes ReadCompleted() to DTE --> don't make it here at all.

// This is because DTE may have made timed read and when timer runs

// out C32 wants to complete read by KErrTimedOut.

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

//

TInt CDpRx2Dte::ResetDteRead()

    {

    OstTrace0( TRACE_NORMAL, CDPRX2DTE_RESETDTEREAD, "CDpRx2Dte::ResetDteRead" );

    OstTrace1( TRACE_NORMAL, DUP1_CDPRX2DTE_RESETDTEREAD, "CDpRx2Dte:: Port: %u", iDataPort.PortUnit() );

    LOGM1("CDpRx2Dte::ResetDteRead - Port %d", iDataPort.PortUnit() );

    // reset pointer pointing into client space & its length

    iReadPending = EFalse;

    iClientBuffer = 0;

    iClientBufferLength = 0;

    iClientRequestedLength = 0;

    iIPCWriteOffset = 0;

    return KErrNone;

    }

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

// CDpRx2Dte::Write

// Reserve read element and IPCWrite data to client space.

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

//

TInt CDpRx2Dte::Write()

    {

    OstTrace0( TRACE_NORMAL, CDPRX2DTE_WRITE, "CDpRx2Dte::Write" );

    OstTrace1( TRACE_NORMAL, DUP1_CDPRX2DTE_WRITE, "CDpRx2Dte:: Port: %u", iDataPort.PortUnit() );

    LOGM1("CDpRx2Dte::Write - Port %d", iDataPort.PortUnit() );

    TInt len( 0 );

    TInt maxLen( 0 );

    TInt ret( KErrNone );

    TCommRole role;

    iDataPort.GetRole( role );

    // verify read pending, else do nothing

    if ( !iReadPending )

        {

        ret = KErrNotReady;

        }

    // check line fail

    else if ( iDataConfig.IsLineFail( role ) )

        {

        iDataPort.ReadCompleted( KErrCommsLineFail );

        ResetDteRead();

        }

    else

        {

        // Find maximum length. i.e. which one is smaller our

        // maximum reservation size or client buffer to write

        // We can't write data over client buffer size -> smaller must be chocen

        maxLen = FindMaximumLength();

        // Lenght is count of bytes before break, but maximum maxLen or

        // lenght is as much as possible, but maximum maxLen

        len = FindLength( maxLen );

        LOG1("  CDpRx2Dte::Write, Rx element reservation - len: %d", len );

        OstTrace1( TRACE_NORMAL, DUP8_CDPRX2DTE_WRITE, "CDpRx2Dte:: Rx element reservation - len: %d", len );

        // try reserve read element, if return success descriptors are

        // set into buffer data

        ret = iBufferRx.ReadElement().Reserve( len, iRx, iRxTail, ETrue );

        switch ( ret )

            {

            case KErrNone:

                {

#ifdef _DEBUG

                iTotalReceived = iTotalReceived + iRx.Length();

                OstTrace1( TRACE_NORMAL, DUP2_CDPRX2DTE_WRITE, "CDpRx2Dte:: iBufferRx.UsedBytes = %d", iBufferRx.UsedBytes() );

                OstTraceExt2( TRACE_NORMAL, DUP3_CDPRX2DTE_WRITE, "CDpRx2Dte:: len = %d, Total Received Bytes = %d", iRx.Length(), iTotalReceived );

                OstTraceExt2( TRACE_NORMAL, DUP4_CDPRX2DTE_WRITE, "CDpRx2Dte:: Client buffer size = %d, DP Max. resv. size = %d", (iClientBufferLength - iIPCWriteOffset), iBufferRx.MaxReservationSize() );

                OstTraceExt2( TRACE_NORMAL, DUP5_CDPRX2DTE_WRITE, "CDpRx2Dte:: Chosen maxLength = %d, Elem. reserved length = %d", maxLen, len );

                OstTraceExt2( TRACE_NORMAL, DUP6_CDPRX2DTE_WRITE, "CDpRx2Dte:: iClientBufferLength = %d, iIPCWriteOffset = %d", iClientBufferLength, iIPCWriteOffset );

                if( iRx.Length() > 0 )

                    {

                    OstTraceExt1( TRACE_NORMAL, DUP7_CDPRX2DTE_WRITE, "CDpRx2Dte:: RX = %s", iRx );

                    }

                else

                    {

                    OstTrace0( TRACE_NORMAL, DUP12_CDPRX2DTE_WRITE, "CDpRx2Dte:: RX buffer empty" );

                    }

                LOG1("  \tiBufferRx.UsedBytes() = %d", iBufferRx.UsedBytes() );

                LOG2("  \tlen = %d, Total Received Bytes = %d",

                    iRx.Length(), iTotalReceived );

                LOG2(" \tClient buffer size = %d, DP Max. resv. size = %d",

                    ( iClientBufferLength - iIPCWriteOffset ),

                    iBufferRx.MaxReservationSize() );

                LOG2(" \tChocen maxLength = %d, Elem. reserved length = %d",

                    maxLen, len );

                LOG2(" \tiClientBufferLength = %d, iIPCWriteOffset = %d",

                    iClientBufferLength, iIPCWriteOffset );

                LOGHEX( iRx, EFalse );

#endif

                if ( iRxTail.Length() )

                    {

                    OstTrace1( TRACE_NORMAL, DUP9_CDPRX2DTE_WRITE, "CDpRx2Dte:: len tail = %d", iRxTail.Length() );

                    OstTraceExt1( TRACE_NORMAL, DUP10_CDPRX2DTE_WRITE, "CDpRx2Dte:: RXTail = %s", iRxTail );

                    LOG1("  \tlen tail = %d", iRxTail.Length() );

                    LOGHEX( iRxTail, EFalse );

                    }

                //no else

                // Write operation is handled here.

                ret = MakeRx2DteWrite( len );

                break;

                }

            case KErrNotReady:

                {

                // we are set active in RunL

                // OBS: returning KErrNone

                ret = KErrNone;

                break;

                }

            default:

                {

                LOG1("  ERROR, CDpRx2Dte::Write Element reservation FAILED, error code: %d",

                    ret );

                OstTrace1( TRACE_NORMAL, DUP11_CDPRX2DTE_WRITE, "ERROR, CDpRx2Dte::Write Element reservation FAILED, error code: %d", ret );

                // returning error code. There's no need to leave because

                // the error situation can be handeled.

                }

            }

        }

    // if there is still data in buffer we are signalled from

    // 1. CDpRx2Dte::SetDteRead when client makes new read

    // 2. from end of RunL when buffer has data and read is pending

    return ret;

    }

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

// CDpRx2Dte::ReleaseNotify

// This method signals ourselves (Rx2Dte).

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

//

void CDpRx2Dte::ReleaseNotify()

    {

    OstTrace0( TRACE_NORMAL, CDPRX2DTE_RELEASENOTIFY, "CDpRx2Dte::ReleaseNotify" );

    LOG("CDpRx2Dte::ReleaseNotify");

    // signal ourselves

    if ( iRequestActive )

        {

        iRequestActive = EFalse;

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

        }

    //no else

    }

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

// CDpRx2Dte::FlushNotify

// This method notifies that buffer is flushed. Classes which have access

// to buffers are derived from this class. Derived class could override

// this method, otherwise this default method will be used.

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

//

void CDpRx2Dte::FlushNotify()

    {

    OstTrace0( TRACE_NORMAL, CDPRX2DTE_FLUSHNOTIFY, "CDpRx2Dte::FlushNotify" );

    LOGM("CDpRx2Dte::FlushNotify()");

    ReleaseNotify();

    }

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

// CDpRx2Dte::Role

// This method gets the role (reader/writer) of data client.

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

//

TUint8 CDpRx2Dte::Role()

    {

    OstTrace0( TRACE_NORMAL, CDPRX2DTE_ROLE, "CDpRx2Dte::Role" );

    return iRole;

    }

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

// CDpRx2Dte::SetBreakBytes

// Set break bytes to be send before break. If no breakbytes

// we can complete break notify right here.

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

//

void CDpRx2Dte::SetBreakBytes(

    const TInt aBreakBytes )

    {

    OstTrace0( TRACE_NORMAL, CDPRX2DTE_SETBREAKBYTES, "CDpRx2Dte::SetBreakBytes" );

    LOGM("CDpRx2Dte::SetBreakBytes");

    iBreakBytes = aBreakBytes;

    if ( iBreakBytes > 0 )

        {

        // there is some data before break

        iBreakPending = ETrue;

        }

    else

        {

        // data before break has sent

        iDataPort.BreakNotifyCompleted( KErrNone );

        iBreak.SetBreakNotify( EFalse );

        iBreakPending = EFalse;

        }

    }

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

// CDpRx2Dte::EchoTx

// We are requested to write TX data back to client buffer.

//  - Append echo data to small buffer.

//  - Signal ourselves to data be written into client space

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

//

void CDpRx2Dte::EchoTx(

    const TPtr8& aEchoData )

    {

    OstTrace0( TRACE_NORMAL, CDPRX2DTE_ECHOTX, "CDpRx2Dte::EchoTx" );

    LOGM("CDpRx2Dte::EchoTx");