/*

* 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 <pipeisi.h>        // isi pipe

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

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

#include "dpdataconfig.h"   // configuration store

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

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

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

#include "dplog.h"          // dataport logging

#include <pipe_sharedisi.h>

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "dpdataconfigTraces.h"

#endif

// LOCAL FUNCTION PROTOTYPES

// none

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

// none

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

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

// DPDataConfig::NewL

// Creates a new  DPDataConfig object instance

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

CDpDataConfig *CDpDataConfig::NewL(

    CDpDataPort& aDataPort )

    {

    OstTrace0( TRACE_NORMAL, CDPDATACONFIG_NEWL, "CDpDataConfig::NewL" );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// DPDataConfig::ConstructL

// Initialises object attributes

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

void CDpDataConfig::ConstructL()

    {

    OstTrace0( TRACE_NORMAL, CDPDATACONFIG_CONSTRUCTL, "CDpDataConfig::ConstructL" );

    // set role capabilities

    User::LeaveIfError( SetRoleCap( iRole ) );

    }

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

// CDpDataConfig::CDpDataConfig

// C++ default constructor.

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

CDpDataConfig::CDpDataConfig(

    CDpDataPort& aDataPort ) :

    iDataPort( aDataPort )

    {

    OstTrace0( TRACE_NORMAL, CDPDATACONFIG_CDPDATACONFIG, "CDpDataConfig::CDpDataConfig" );

    LOGM(" CDpDataConfig::CDpDataConfig");

    iDataPort.GetRole( iRole );

    iDteParityBitWhen7Mode = PEP_COMM_DATA_WITH_PARITY;

    // set default configuration

    iConfig.iRate = EBps9600;

    // default data format 8N1

    iConfig.iDataBits = EData8;

    iConfig.iStopBits = EStop1;

    iConfig.iParity = EParityNone;

    // DTE defaults

    iConfig.iHandshake = KConfigObeyCTS;

    // Other options to handshake default:

    // KConfigObeyXoff

    // KConfigSendXoff

    // KConfigObeyCTS;

    // KConfigObeyDSR

    // KConfigObeyDCD

    // KConfigFreeRTS

    // KConfigFreeDTR

    // not really applicable

    iConfig.iFifo = EFifoEnable;

    // use no special rate

    iConfig.iSpecialRate = 0;

    // use no terminators

    iConfig.iTerminatorCount = 0;

    // set XON/XOFF characters into 'typical' values

    iConfig.iXonChar = KDcsDefaultXonChar;

    iConfig.iXoffChar = KDcsDefaultXoffChar;

    // ignore parity errors

    iConfig.iParityError = KConfigParityErrorIgnore;

    // ignoring parity errors

    iConfig.iParityErrorChar = 0;

    // we do no IR

    iConfig.iSIREnable = ESIRDisable;

    iConfig.iSIRSettings = 0;

    // flowcontrol extraction

    iFlowCtrlCharExtraction = ETrue;

    iSignals = 0;

    // signals are low, but signal changed bits are up

    // that is because otherwise we might miss clients first signal change,

    // case of signal change is up->low.

    // set capabilities

    // data rate

    iCapsV02.iRate =

        KCapsBps2400 |

        KCapsBps4800 |

        KCapsBps9600 |

        KCapsBps19200 |

        KCapsBps38400 |

        KCapsBps57600 |

        KCapsBps115200;

        //| KCapsBpsSpecial; // unsupported currently

    // data bits

    iCapsV02.iDataBits = KCapsData7 | KCapsData8;

    // stop bits

    iCapsV02.iStopBits = KCapsStop1 | KCapsStop2;

    // parity

    iCapsV02.iParity =

        KCapsParityNone |

        KCapsParityOdd |

        KCapsParityEven |

        KCapsParityMark |

        KCapsParitySpace;

    iCapsV02.iSignals =

        KCapsSignalDSRSupported |

        KCapsSignalDCDSupported |

        KCapsSignalDTRSupported |

        KCapsSignalRNGSupported;

    // not really applicable

    // KCapsHasFifo;

    iCapsV02.iFifo = 0;

    // no IR

    iCapsV02.iSIR = 0;

    // supported notifications

    iCapsV02.iNotificationCaps =

        KNotifySignalsChangeSupported |

        KNotifyRateChangeSupported |

        KNotifyDataFormatChangeSupported |

        KNotifyHandshakeChangeSupported |

        KNotifyBreakSupported |

        KNotifyFlowControlChangeSupported |

        KNotifyDataAvailableSupported |

        KNotifyOutputEmptySupported;

    iCapsV02.iRoleCaps = KCapsRoleSwitchSupported;

    // port supports retrieval of flow control status

    iCapsV02.iFlowControlCaps = KCapsFlowControlStatusSupported;

    // '+'

    iEscChar = KEscChar;

    // in 50 millisec note: previous comment was in 20 milliseconds

    iEscTime = KEscTime50millisec;

    }

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

// CDpDataConfig::~CDpDataConfig

// Destructor

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

CDpDataConfig::~CDpDataConfig()

    {

    OstTrace0( TRACE_NORMAL, DUP1_CDPDATACONFIG_CDPDATACONFIG, "CDpDataConfig::~CDpDataConfig" );

    LOGM(" CDpDataConfig::~CDpDataConfig");

    }

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

// CDpDataConfig::SetRoleCap

// Sets role Capabalities

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

//

TInt CDpDataConfig::SetRoleCap(

    TCommRole aRole )

    {

    OstTrace0( TRACE_NORMAL, CDPDATACONFIG_SETROLECAP, "CDpDataConfig::SetRoleCap" );

    TInt ret( KErrNone );

    switch ( aRole )

        {

        case ECommRoleDTE:

            {

            // we cope with both sw & hw flow control

            iCapsV02.iHandshake =

                KCapsObeyXoffSupported |

                KCapsSendXoffSupported |

                KCapsObeyCTSSupported |

                KCapsObeyDSRSupported |

                KCapsObeyDCDSupported |

                KCapsFreeDTRSupported |

                KCapsFailDCDSupported |

                KCapsFreeRTSSupported;

            break;

            }

        case ECommRoleDCE:

            {

            // we cope with sw flow control and RTS DTR

            iCapsV02.iHandshake =

                KCapsObeyXoffSupported |

                KCapsSendXoffSupported |

                KCapsObeyCTSSupported |

                KCapsObeyDTRSupported |

                0x1000 | // KCapsObeyRTSSupported

                0x4000 | // KCapsFreeDSRSupported

                0x10000; // KCapsFreeDCDSupported

            break;

            }

        default:

            {

            ret = KErrGeneral;

            break;

            }

        }

    return ret;

    }

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

// CDpDataConfig::GetCommCaps

// This method gets port capabilities in TCommCapsV01.

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

//

void CDpDataConfig::GetCommCaps(

    TCommCapsV01& aCommCaps ) const

    {

    OstTrace0( TRACE_NORMAL, CDPDATACONFIG_GETCOMMCAPS, "CDpDataConfig::GetCommCaps" );

    LOGM(" CDpDataConfig::GetCommCaps");

    aCommCaps.iRate = iCapsV02.iRate;

    aCommCaps.iDataBits = iCapsV02.iDataBits;

    aCommCaps.iStopBits = iCapsV02.iStopBits;

    aCommCaps.iParity = iCapsV02.iParity;

    aCommCaps.iHandshake = iCapsV02.iHandshake;

    aCommCaps.iSignals = iCapsV02.iSignals;

    aCommCaps.iFifo = iCapsV02.iFifo;

    aCommCaps.iSIR = iCapsV02.iSIR;

    }

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

// CDpDataConfig::GetCommCapsV02

// This method gets port capabilities in TCommCapsV02.

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

//

void CDpDataConfig::GetCommCapsV02(

    TCommCapsV02& aCommCaps2 ) const

    {

    OstTrace0( TRACE_NORMAL, CDPDATACONFIG_GETCOMMCAPSV02, "CDpDataConfig::GetCommCapsV02" );

    LOGM(" CDpDataConfig::GetCommCapsV02");

    GetCommCaps( aCommCaps2 );

    aCommCaps2.iNotificationCaps = iCapsV02.iNotificationCaps;

    aCommCaps2.iRoleCaps = iCapsV02.iRoleCaps;

    aCommCaps2.iFlowControlCaps = iCapsV02.iFlowControlCaps;

    }

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

// CDpDataConfig::SetConfig

// This method sets DTE interface port configuration

// settings.

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

//

TInt CDpDataConfig::SetConfig(

    TCommConfigV01& aConfig )

    {

    OstTrace0( TRACE_NORMAL, CDPDATACONFIG_SETCONFIG, "CDpDataConfig::SetConfig" );

    LOGM(" CDpDataConfig::SetConfig");

    TInt ret( KErrNone );

    //Initialise these values to 0

    TUint8 rate( 0 );

    TUint8 dataBits( 0 );

    TUint8 stopBits( 0 );

    TUint8 parity( 0 );

    TBool saveSettings ( EFalse );

    // Check against supported values, NOTE: caps is a bitmask,

    // when config is enumerated.

    if ( !( iCapsV02.iRate & ( 1 << aConfig.iRate ) ) )

        {

        ret = KErrNotSupported;

        }

    else if ( !( iCapsV02.iDataBits & ( 1 << aConfig.iDataBits ) ) )

        {

        ret = KErrNotSupported;

        }

    else if ( !( iCapsV02.iStopBits & ( 1 << aConfig.iStopBits ) ) )

        {

        ret = KErrNotSupported;

        }

    else if ( !( iCapsV02.iParity & ( 1 << aConfig.iParity ) ) )

        {

        ret = KErrNotSupported;

        }

    else if ( ( ~iCapsV02.iHandshake & aConfig.iHandshake ) &&

        ( 0 != aConfig.iHandshake ) )

        {

        ret = KErrNotSupported;

        }

    else

        {

        // We do not parity check, disable fifo, do special rate nor IR.

        if ( ( aConfig.iParityError != KConfigParityErrorIgnore ) ||

            ( aConfig.iFifo != EFifoEnable ) ||

            aConfig.iSpecialRate ||

            aConfig.iParityErrorChar ||

            ( aConfig.iSIREnable != ESIRDisable ) ||

            aConfig.iSIRSettings )

            {

            LOG("  ERROR, SetConfig - KErrNotSupported");

            OstTrace0( TRACE_NORMAL, DUP1_CDPDATACONFIG_SETCONFIG, "CDpDataConfig:: ERROR, SetConfig - KErrNotSupported" );

            ret = KErrNotSupported;

            }

        else if ( KConfigMaxTerminators < aConfig.iTerminatorCount )

            {

            LOG("  ERROR, CDpDataConfig::SetConfig, KErrArgument");

            OstTrace0( TRACE_NORMAL, DUP2_CDPDATACONFIG_SETCONFIG, "CDpDataConfig:: ERROR, SetConfig - KErrArgument" );

            ret = KErrArgument;

            }

        // We care only databits, stopbits and parity changes.

        // We don't send message to CMT when only speed has changed.

        // CMT is not using speed setting at all.

        else if ( ( iConfig.iDataBits == aConfig.iDataBits ) &&

            ( iConfig.iStopBits == aConfig.iStopBits ) &&

            ( iConfig.iParity == aConfig.iParity ) )

            {

            // Save settings, to return same

            // settings when client is asking them.

            iConfig = aConfig;

            saveSettings = ETrue;

            }

        // Do parameter mapping.

        // check data rate

        else if ( KErrNone != Rate( aConfig, rate ) )

            {

            ret = Rate( aConfig, rate );

            }

        // check data bits

        else if ( KErrNone != DataBits( aConfig, dataBits ) )

            {

            ret = DataBits( aConfig, dataBits );

            }

        // check stop bits

        else if ( KErrNone != StopBits( aConfig, stopBits ) )

            {

            ret = StopBits( aConfig, stopBits );

            }

        // check parity

        else if ( KErrNone != Parity( aConfig, parity ) )

            {

            ret = Parity( aConfig, parity );

            }

        //no else

        if ( KErrNone == ret && !saveSettings )

            {

            // this is for if Client uses SetConfig before we have pipe up.

            if ( CDpPif::EDpPipeEnabled != iDataPort.Pif().PipeState() )

                {

                ret = KErrNotReady;

                }

            else

                {

                // Create PNS_PEP_STATUS_IND : PEP_COMM_IND_ID_PARAM

                // (Indication data, PEP_COMM_CTRL_ID_PARAM_STR size = 4 bytes)

                TBuf8<SIZE_PNS_PEP_STATUS_IND + 4 > messageData;

                // Pipe Handle

                messageData.Append( iDataPort.Pif().PipeHandle() );

                // PEP Type

                messageData.Append( PN_PEP_TYPE_COMM );

                // Indication ID

                messageData.Append( PEP_COMM_IND_ID_PARAM );

                // Filler bytes

                messageData.Append( KDpPadding );

                messageData.Append( KDpPadding );

                // Indication data (PEP_COMM_CTRL_ID_PARAM_STR)

                messageData.Append( dataBits );

                messageData.Append( stopBits );

                messageData.Append( rate );

                messageData.Append( parity );

                // Send messages

                TInt result = iDataPort.Mif().SendMessage(

                    PN_PIPE,

                    iDataPort.CreateTransactionId(),

                    PNS_PEP_STATUS_IND,

                    messageData );

                LOG("  <== PNS_PEP_STATUS_IND ind sent (PEP_COMM_IND_ID_PARAM)");

                OstTrace0( TRACE_NORMAL, DUP3_CDPDATACONFIG_SETCONFIG, "CDpDataConfig:: <== PNS_PEP_STATUS_IND ind sent (PEP_COMM_IND_ID_PARAM)" );

#if defined(_DEBUG)

                if ( KErrNone != result )

                    {

                    LOG1("Error isc api send %d", result );

                    OstTrace1( TRACE_NORMAL, DUP4_CDPDATACONFIG_SETCONFIG, "CDpDataConfig:: Error isc api send %d", result );

                    }

                //no else

#endif

                // accept new values

                iConfig = aConfig;

                }

            }

        //no else

        }

    return ret;

    }

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

// CDpDataConfig::GetSignals

// This method gets status of signals.

////  On return, contains signals

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

//

void CDpDataConfig::GetSignals(

    TUint& aSignals )

    {

    OstTrace0( TRACE_NORMAL, CDPDATACONFIG_GETSIGNALS, "CDpDataConfig::GetSignals" );

    LOGM(" CDpDataConfig::GetSignals");

    aSignals = iSignals;

    }

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

// CDpDataConfig::SetSignals2Epoc

// Signal cahnges from CMT. This method sets signal values.

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

//

TInt CDpDataConfig::SetSignals2Epoc(

    const TUint aSignals )

    {

    OstTrace0( TRACE_NORMAL, CDPDATACONFIG_SETSIGNALS2EPOC, "CDpDataConfig::SetSignals2Epoc" );

    LOGM(" CDpDataConfig::SetSignals2Epoc");

    TCommRole role;

    TUint newSignals( 0 );

    iDataPort.GetRole( role );

    // accept new signals

    iSignals = aSignals;

    // signal change came from DCS

    if ( iSignalNotify )

        {

        newSignals = iSignals & (

            iNotifySignalMask | iNotifySignalMask * KSignalChanged );

        if ( ECommRoleDTE == role )

            {

            newSignals &= ( KSignalDTEInputs | KDTEDeltaInput );

            }

        else

            {

            newSignals &= ( KSignalDCEInputs | KDCEDeltaInput );

            }

        // we should indicate client

        CompleteSignalChangeNotify( newSignals );

        }

    //no else

    return KErrNone;

    }

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

// CDpDataConfig::SetSignals2Cmt

// Signal changes from the C32 client.

// This method sends mapped signal values to CMT and sets

// signal values.

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

//

TInt CDpDataConfig::SetSignals2Cmt(

    const TUint aSignals )

    {

    OstTrace0( TRACE_NORMAL, CDPDATACONFIG_SETSIGNALS2CMT, "CDpDataConfig::SetSignals2Cmt" );

    LOGM(" CDpDataConfig::SetSignals2Cmt");