/*

* 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 <e32svr.h>

#include <e32std.h>

#include <e32uid.h>              // epoc32 uids

#include <iscapi.h>

#include <iscnokiadefinitions.h>

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

#include "dpstd.h"               // fault codes etc.

#include "dpdatabuffer.h"        // base class for rx and tx buffers

#include "dpdataconfig.h"        // port configuration store

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

#include "dpmif.h"               // message interface mif

#include "dpdte2tx.h"            // moves data from client to tx buffer

#include "dptx2pn.h"             // moves data from tx buffer to isaapi

#include "dppn2rx.h"             // moves data from isaapi to rx buffer

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

#include "dpcommpep.h"           // comm pep interface. interaction with mif

#include "dpescdetect.h"         // escape sequence detection

#include "dpbreak.h"             // break signal handling

#include "dpparityhandler.h"     // parity bit handling in 7-bit data mode

#include "dppif.h"               // pipe interface pif

#include "dptermdetect.h"        // terminal bytes detection

#include "pep_comm_types.h"      // structures for isi-message interface

#include "dplog.h"               // dataport logging

#include "osttracedefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "dpdataporttraces.h"

#endif

// LOCAL FUNCTION PROTOTYPES

static void CloseObject( TAny* aObject );

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

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

// CloseObject Close an object from the cleanup stack

// Status : Proposal

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

//

void CloseObject(

    TAny* aObject )

    {

    OstTrace0( TRACE_NORMAL, LOCAL_CLOSEOBJECT, "CloseObject" );

    ( ( CObject* ) aObject )->Close();

    }

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

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

// CDpDataPortFactory::CDpDataPortFactory

// C++ default constructor

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

CDpDataPortFactory::CDpDataPortFactory()

    {

    OstTrace0( TRACE_NORMAL, CDPDATAPORTFACTORY_CDPDATAPORTFACTORY, "CDpDataPortFactory::CDpDataPortFactory" );

    LOGM(" CDpDataPortFactory::CDpDataPortFactory");

    }

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

// CDpDataPortFactory::ConstructL

// Symbian 2nd phase constructor

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

void CDpDataPortFactory::ConstructL()

    {

    OstTrace0( TRACE_NORMAL, CDPDATAPORTFACTORY_CONSTRUCTL, "CDpDataPortFactory::ConstructL" );

    LOGM(" CDpDataPortFactory::ConstructL");

    TName name( KDataPortModule ); // Used in RComm::Open()

    SetNameL( &name );

    //A version is defined by a set of three numbers

    iVersion = TVersion( EMajorVersion, EMinorVersion, EBuild );

    //Create a parity handler object

    iParityHandler = new( ELeave ) CDpParityHandler();

    }

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

// CDpDataPortFactory::NewL

// Static constructor

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

CDpDataPortFactory* CDpDataPortFactory::NewL()

    {

    OstTrace0( TRACE_NORMAL, CDPDATAPORTFACTORY_NEWL, "CDpDataPortFactory::NewL" );

    LOGM("CDpDataPortFactory::NewL");

    CDpDataPortFactory* self = new( ELeave ) CDpDataPortFactory;

    TCleanupItem closePort( CloseObject, self );

    CleanupStack::PushL( closePort );

    self->ConstructL();

    CleanupStack::Pop(); //closePort

    return self;

    }

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

// CDpDataPortFactory::~CDpDataPortFactory

// Destructor

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

CDpDataPortFactory::~CDpDataPortFactory()

    {

    OstTrace0( TRACE_NORMAL, DUP1_CDPDATAPORTFACTORY_CDPDATAPORTFACTORY, "CDpDataPortFactory::~CDpDataPortFactory" );

    LOGM(" CDpDataPortFactory::~CDpDataPortFactory");

    if ( iParityHandler )

        {

        delete iParityHandler;

        }

    // no else

    }

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

// CDpDataPortFactory::NewPortL

// This method creates a new port. This function leaves with

// KErrNotSupported, if unit number is not between

// KDataPortCommLowUnit and KDataPortCommHighUnit.

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

//

CPort* CDpDataPortFactory::NewPortL(

    const TUint aUnit )

    {

    OstTrace0( TRACE_NORMAL, CDPDATAPORTFACTORY_NEWPORTL, "CDpDataPortFactory::NewPortL" );

    OstTrace1( TRACE_NORMAL, DUP1_CDPDATAPORTFACTORY_NEWPORTL, "CDpDataPortFactory:: aUnit: %u", aUnit );

    LOGM1("CDpDataPortFactory::NewPortL, unit: %d", aUnit );

    __ASSERT_ALWAYS( KDataPortCommHighUnit >= aUnit,

        User::Leave( KErrNotSupported ) );

    //Create a CDpDataPort object

    return reinterpret_cast<CPort *>(

        CDpDataPort::NewL( aUnit, iParityHandler ) );

    }

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

// CDpDataPortFactory::Info

// This method fills in the supplied serial info structure.

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

//

void CDpDataPortFactory::Info(

    TSerialInfo &aSerialInfo )

    {

    OstTrace0( TRACE_NORMAL, CDPDATAPORTFACTORY_INFO, "CDpDataPortFactory::Info" );

    LOGM("CDpDataPortFactory::Info");

    aSerialInfo.iDescription = KDataPortDescription;

    aSerialInfo.iName = KDataPortModule;

    aSerialInfo.iLowUnit = KDataPortCommLowUnit;

    aSerialInfo.iHighUnit = KDataPortCommHighUnit;

    }

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

// CDpDataPortFactory::PortPlatSecCapability

// This method returns capabilities for requested port.

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

//

TSecurityPolicy CDpDataPortFactory::PortPlatSecCapability(

    TUint aPort ) const

    {

    OstTrace0( TRACE_NORMAL, CDPDATAPORTFACTORY_PORTPLATSECCAPABILITY, "CDpDataPortFactory::PortPlatSecCapability" );

    OstTrace1( TRACE_NORMAL, DUP1_CDPDATAPORTFACTORY_PORTPLATSECCAPABILITY, "CDpDataPortFactory:: aPort: %u", aPort );

    LOGM1("CDpDataPortFactory::PortPlatSecCapability - port %d",

        aPort );

    TSecurityPolicy csySecurityPolicy;

    // Support for ports 0, 1, (2, 3,) 4, 5 & 6

    switch ( aPort )

        {

        case KDpCsdPort:

            {

            csySecurityPolicy = TSecurityPolicy(

                ECapabilityNetworkServices,

                ECapabilityNetworkControl,

                ECapabilityCommDD );

            break;

            }

        case KDpDialUpPort:

            {

            csySecurityPolicy = TSecurityPolicy(

                ECapabilityNetworkServices,

                ECapabilityNetworkControl,

                ECapabilityCommDD );

            break;

            }

        case KDpPort4:

        case KDpPort5:

        case KDpPort6:

            {

            csySecurityPolicy = TSecurityPolicy(

                ECapabilityNetworkServices,

                ECapabilityNetworkControl,

                ECapabilityCommDD );

            break;

            }

        case KDpBtAccHfPort:

        case KDpBtAccHsPort:

        // These ports 2 and 3 are implemented in Dataport and ISA for BT

        // handsfree and headset but they are in fact not used in S60 3.X ->

        default:

            {

            csySecurityPolicy = TSecurityPolicy(

                TSecurityPolicy::EAlwaysFail );

            break;

            }

        }

    return csySecurityPolicy;

    }

//===========================================================

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

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

// CDpDataPort::CDpDataPort

// C++ default constructor

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

CDpDataPort::CDpDataPort(

    CDpParityHandler* aParityHandler,

    const TInt aUnit ) :

    iRole( ECommRoleDTE ),

    iUnit( aUnit ),

    iParityHandler( aParityHandler )

    {

    OstTrace0( TRACE_NORMAL, CDPDATAPORT_CDPDATAPORT, "CDpDataPort::CDpDataPort" );

    LOGM(" CDpDataPort::CDpDataPort");

    }

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

// CDpDataPort::NewL

// Static constructor

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

CDpDataPort* CDpDataPort::NewL(

    const TUint aUnit,

    CDpParityHandler* aParityHandler )

    {

    OstTrace0( TRACE_NORMAL, CDPDATAPORT_NEWL, "CDpDataPort::NewL" );

    LOGM("CDpDataPort::NewL");

    CDpDataPort *self = new( ELeave ) CDpDataPort( aParityHandler, aUnit );

    TCleanupItem closePort( CloseObject, self );

    CleanupStack::PushL( closePort );

    // closePort is enough for cleaning purposes,

    // because CPort::Close() calls Destruct()

    self->InitL();

    TName name;

    _LIT( KUnitFormat, "%d" );

    name.Format( KUnitFormat, aUnit );

    self->SetName( &name );

    CleanupStack::Pop(); //closePort

    return self;

    }

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

// CDpDataPort::~CDpDataPort

// Destructor

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

CDpDataPort::~CDpDataPort()

    {

    OstTrace0( TRACE_NORMAL, DUP1_CDPDATAPORT_CDPDATAPORT, "CDpDataPort::~CDpDataPort" );

    OstTrace1( TRACE_NORMAL, DUP2_CDPDATAPORT_CDPDATAPORT, "CDpDataPort:: Port: %u", iUnit );

    LOGM1(" CDpDataPort::~CDpDataPort - Port %d", iUnit );

    DeleteCommonObjects();

    }

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

// CDpDataPort::DeleteDataPort

// This method deletes DataPort

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

//

void CDpDataPort::DeleteDataPort()

    {

    OstTrace0( TRACE_NORMAL, CDPDATAPORT_DELETEDATAPORT, "CDpDataPort::DeleteDataPort" );

    if ( this )

        {

        delete this;

        }

    //no else

    }

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

// CDpDataPort::IsReadyToDestruct

// This method finds out, whether DataPort is ready to be destructed.

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

//

TBool CDpDataPort::IsReadyToDestruct()

    {

    OstTrace0( TRACE_NORMAL, CDPDATAPORT_ISREADYTODESTRUCT, "CDpDataPort::IsReadyToDestruct" );

    return iReadyToDestruct;

    }

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

// CDpDataPort::DeleteCommonObjects

// This method deletes other objects and starts pipe

// termination. All operations are cancelled before

// deletion.

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

//

void CDpDataPort::DeleteCommonObjects()

    {

    OstTrace0( TRACE_NORMAL, CDPDATAPORT_DELETECOMMONOBJECTS, "CDpDataPort::DeleteCommonObjects" );

    LOGM(" CDpDataPort::DeleteCommonObjects");

    // Close the pipe only if it has not been closed before

    if ( iPifDcs && !iReadyToDestruct )

        {

        TRAP_IGNORE( iPifDcs->ClosePipeL( iUnit ) );

        }

    //no else

    // Cancel all operations

    if ( iTx2Pn )

        {

        iTx2Pn->Cancel();

        }

    //no else

    if ( iPn2Rx )

        {

        iPn2Rx->Cancel();

        }

    //no else

    if ( iRx2Dte )

        {

        iRx2Dte->Cancel();

        }

    //no else

    if ( iDte2Tx )

        {

        iDte2Tx->Cancel();

        }

    //no else

    if ( iPifDcs )

        {

        iPifDcs->Cancel();

        }

    //no else

    if ( iMif )

        {

        iMif->Cancel();

        }

    //no else

    if ( iEscDetect )

        {

        iEscDetect->Cancel();

        }

    //no else

    if ( iFlowCtrl )

        {

        iFlowCtrl->Cancel();

        }

    //no else

    // Deallocate subjects before observers

    if ( iISAHandle )

        {

        iISAHandle->Close();

        }

    //no else

    if ( iDte2Tx )

        {

        delete iDte2Tx;

        iDte2Tx = NULL;

        }

    //no else

    if ( iTx2Pn )

        {

        delete iTx2Pn;

        iTx2Pn = NULL;

        }

    //no else

    if ( iPn2Rx )

        {

        delete iPn2Rx;

        iPn2Rx = NULL;

        }

    //no else

    if ( iPifDcs )

        {

        delete iPifDcs;

        iPifDcs =NULL;

        }

    //no else

    if ( iFlowCtrl )

        {

        delete iFlowCtrl;

        iFlowCtrl = NULL;

        }

    //no else

    if ( iMif )

        {

        delete iMif;

        iMif = NULL;

        }

    //no else

    if ( iRx2Dte )

        {

        delete iRx2Dte;

        iRx2Dte = NULL;

        }

    //no else

    if ( iDataConfig )

        {

        delete iDataConfig;

        iDataConfig = NULL;

        }

    //no else

    if ( iCommPep )

        {

        delete iCommPep;

        iCommPep = NULL;

        }

    //no else

    if ( iEscDetect )

        {

        delete iEscDetect;

        iEscDetect = NULL;

        }

    //no else

    if ( iTermDetect )

        {

        delete iTermDetect;

        iTermDetect = NULL;

        }

    //no else

    if ( iBreak )

        {

        delete iBreak;

        iBreak = NULL;

        }

    //no else

    if ( iRx )

        {

        delete iRx;

        iRx = NULL;

        }

    //no else

    if ( iTx )

        {

        delete iTx;

        iTx = NULL;

        }

    //no else

    if ( iISAHandle )

        {

        delete iISAHandle;

        iISAHandle = NULL;

        }

    //no else

    }

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

// CDpDataPort::InitL

// This method opens Isc Api handle and creates other objects.

// Status : Proposal

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

//

void CDpDataPort::InitL()

    {

    OstTrace0( TRACE_NORMAL, CDPDATAPORT_INITL, "CDpDataPort::InitL" );

#ifdef USE_FILE_SERIAL_TRUST_DEBUG // for debugging purposes

    iDebugBytesFromDte   = 0;

    iDebugBytesToPn      = 0;

    iDebugBytesFromPn    = 0;

    iDebugBytesToDte     = 0;

    iDebugDteWrites      = 0;

    iDebugDteReads       = 0;

    iDebugPnWrites       = 0;

    iDebugPnReads        = 0;

#ifdef USE_FILE_DEBUG

    User::LeaveIfError( iFileServer.Connect( ) );

    User::LeaveIfError(

        iFile.Replace( iFileServer, KDataPortFileName, EFileWrite ) );

#endif // USE_FILE_DEBUG