// Copyright (c) 2002-2009 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:

// Implements a complete CSY for physical serial ports

// 

//

/**

 @file

*/

#include <cs_port.h>

#include <d32comm.h>

#include <c32comm.h>

#include <e32hal.h>

// new header file introduced in C32 V2, old ecuart had no header file

#include "ECUART.H"

#include <c32comm_internal.h>

// This header import is new for C32 V2 but is not configured since then we don't need to configure all

// the logging we've added to this file during V2. The ecuartlog header file when pre-processed for pre-V2

// will resolve all the logging to nothing since all its log macros for pre-V2 are defined empty.

#include "ECUARTLOG.H"

const TUint KCommLowUnit=0;  //< lowest port unit number for this CSY (i.e. COMM::0)

#if defined(__WINS__)

const TUint KCommHighUnit=1; //< highest port unit number for this CSY (i.e. COMM::1)

#else // _MARM_

const TUint KCommHighUnit=0; //< highest port unit number for this CSY (i.e. COMM::0)

#endif

const TUint KDefaultBufSize = 0x100; //< size of the Tx/Rx buffers used in CCommWriter and CCommReader

_LIT(KSerialDescription, "Built in Serial ports"); //< CSY description returned by RCommServ::GetPortInfo

#define SERIAL_NAME _S("COMM")  //< name of prefix for each com port

const TInt KReaderPriority=100; //< priority for the CCommReader active object

const TInt KWriterPriority=50;  //< priority for the CCommWriter active object

const TInt KBreakerPriority=0;  //< priority for the CCommBreaker active object

const TInt KNotifyPriority=0;   //< priority for CCommNotifyBase derived active objects

//Security policy for a port.

class TPortSecurityPolicy

	{

public:

	//Port number which this policy will apply.

	TInt iPort;

	//Security policy.

	TStaticSecurityPolicy iPolicy;

	};

_LIT_SECURITY_POLICY_PASS(KDefaultPortPassPolicy);

_LIT_SECURITY_POLICY_FAIL(KPortAlwaysFailPolicy);

#define KPlaceholderPortNumber -1	//a place holder port number used to initiliase KExplicitPortSecurityPolicies when no other ports require a policy different than the default.

//Define policy for ports which are different from default policy (KDefaultPortPolicy) here.

//Default policy is EAlwaysPass but to provide example ports 0-1 are explicitly set to EAlwaysPass as well.

//Port policies must only apply for port number 0-(KMaxUnits-1).

//Add to this array for other ports that need policing with capabilities.

const TUint KExplicitPortPoliciesCount = 0;	//Count of the number of entries in KExplicitPortSecurityPolicies.  Currently only a place holder entry exists so the count = 0.

const struct TPortSecurityPolicy KExplicitPortSecurityPolicies[]=

	{

	{KPlaceholderPortNumber, _INIT_SECURITY_POLICY_FAIL}	//this is a place holder entry which should be replaced with proper port policy when required to police a port with different capabiltiies to default policy.

//	{0, _INIT_SECURITY_POLICY_C1( ECapabilityCommDD)},	//Example showing explicitly setting a policy different than default for Port 0

//	{1, _INIT_SECURITY_POLICY_C2( ECapabilityReadUserData, ECapabilityWriteUserData)}	//Example showing explicitly setting a policy different than default for Port 1

	};

// #define _DEBUG_CONSOLE_

#if defined(_DEBUG_CONSOLE_)

#include <e32twin.h>

class RDebugConsole : public RConsole

	{

public:

	RDebugConsole();

public:

	void Printf(TRefByValue<const TDesC> aFmt,...);

	};

#define DEBUG_TRACE(m) m

#else	// (_DEBUG)

// debug trace (disabled in Release builds)

#define DEBUG_TRACE(m)

//

#endif

//

// CCommReader CCommWriter and CCommBreaker are active objects which wait on

// completion from the serial channel for various actions.

//

class CHWPort;

/**

 * base class for CCommReader and CCommWriter

 *

 */

class CCommReadWriteBase : public CActive

	{

public:

	CCommReadWriteBase(TInt aPriority, CHWPort* aParent);

	~CCommReadWriteBase();

	TInt SetServerConfig(TCommServerConfig& aConfig);

	void GetServerConfig(TCommServerConfig& aConfig) const;

	void FreeMemory();

	 // set the role of this port unit @param aRole new role

	inline void SetRole(TCommRole aRole){iRole=aRole;};

protected:

	void SetBuffersL();

	// return ETrue if partial buffering used

	TBool UsePartial() {return ((iBufFlags & KCommBufferPartial)==KCommBufferPartial);}

protected:

	HBufC8* iBuffer;  //< pointer to the Tx/Rx buffer

	TPtr8* iBuf;      //< pointer to a TPtr8 that points to the current buffer

	TUint iBufFlags;  //< contains buffer flags e.g for partial read/write

	TInt iBufSize;    //< size of the Tx/Rx buffer

	TCommRole iRole;  //< DTE or DCE role for this port unit

	CHWPort* iParent; //< pointer to the CHWPort object

	};

#if defined (_DEBUG_DEVCOMM) && defined (_DEBUG_CONSOLE_)

class CCommDebugDumper : public CActive

	{

public:

	static CCommDebugDumper* NewL(RDebugConsole &aConsole);

	virtual void RunL();

	virtual void DoCancel();

	CCommDebugDumper::~CCommDebugDumper();

	 // set the role of this port unit @param aRole new role

	inline void SetRole(TCommRole aRole){iRole=aRole;};

private:

	CCommDebugDumper(RDebugConsole &aConsole);

private:

	TCommRole iRole;         //< DTE or DCE role for this port unit

	RDebugConsole *iConsole;

	TConsoleKey iKeystroke;

	};

#endif

/**

 * Active Comm port Reader

 *

 * This class is responsible for reading data from the physical

 * comm port.

 */

class CCommReader : public CCommReadWriteBase

	{

public:

	static CCommReader* NewL(CHWPort* aParent);

	~CCommReader();

	// from CActive

	virtual void DoCancel();

	virtual void RunL();

	//

	void Read(const TAny* aClientBuffer, TInt aLength);

	void ReadCancel();

private:

	CCommReader(CHWPort* aParent);

	void InitL();

private:

	TUint iLength;          //< number of bytes to read

	TAny* iClientBuffer;    //< pointer to Client's buffer

	TUint iBufPos;          //< position in Client's buffer to read into (write)

	TUint iBufActive;       //< TRUE if partial buffering active

	TInt iBufOneOrMoreSize; //< buffer size of ReadOneOrMore method

	};

/**

 * Active Comm port Writer

 *

 * This class is responsible for writing data to the physical

 * comm port.

 */

class CCommWriter : public CCommReadWriteBase

	{

public:

	static CCommWriter* NewL(CHWPort* aParent);

	~CCommWriter();

	// from CActive

	virtual void DoCancel();

	virtual void RunL();

	//

	void Write(const TAny* aClientBuffer, TInt aLength);

	void WriteCancel();

	inline void NotificationEnable();

	inline void NotificationDisable();

	inline TBool IsNotificationEnabled();

private:

	CCommWriter(CHWPort* aParent);

	void InitL();

private:

	TUint iLength;              //< number of bytes to write

	TAny* iClientBuffer;        //< pointer to Client's buffer

	TUint iBufPos;              //< position in Client's buffer to read from

	TUint iBufActive;           //< TRUE if partial buffering active

	TBool iNotificationEnabled; //< true if notification is enabled

	};

/**

 * Active Comm port Breaker

 *

 * This class is responsible for handling breaks on the physical

 * comm port.

 */

class CCommBreaker : public CActive

	{

public:

	static CCommBreaker * NewL(CHWPort* aParent);

	~CCommBreaker();

	// from CActive

	virtual void DoCancel();

	virtual void RunL();

	//

	void Break(TInt aTime);

	 // set the role of this port unit @param aRole new role

	inline void SetRole(TCommRole aRole){iRole=aRole;};

private:

	CCommBreaker(CHWPort* aParent);

private:

	TCommRole iRole;  //< DTE or DCE role for this port unit

	CHWPort* iParent; //< pointer to the CHWPort object

	};

/**

 * Base class for Notifiers

 *

 */

class CCommNotifyBase : public CActive

	{

public:

	 // set the role of this port unit @param aRole new role

	inline void SetRole(TCommRole aRole){iRole=aRole;};

protected:

	CCommNotifyBase(CHWPort* aParent);

	~CCommNotifyBase();

protected:

	TCommRole iRole;  //< DTE or DCE role for this port unit

	CHWPort* iParent; //< pointer to the CHWPort object

	};

/**

 * This class is responsible for notifying the client when

 * the signal control lines are changing, including breaks.

 */

class CCommSignalNotifier : public CCommNotifyBase

	{

public:

	CCommSignalNotifier(CHWPort* aParent);

	~CCommSignalNotifier();

	// from CActive

	virtual void DoCancel();

	virtual void RunL();

	//

	void Start();

	void NotifySignal(TUint aSignalMask);

	void NotifySignalCancel();

	void NotifyBreak();

	void NotifyBreakCancel();

private:

	TUint iSignals;     //< bitmask with the new signal after notification completed

	TUint iSignalMask;  //< bitmask with the signals to be notified

	TInt iNotifyCount;	//< increased when either NotifySignals or NotifyBreak is using this class

						//< decreased when RunL is called. Ensures that RComm::NotifyBreak will not

						//< interfere with operation of RComm::NotifySignalsChange

	};

/**

 * this class is responsible for notifying the client when

 * there are some incoming data available.

 */

class CCommAvailableDataNotifier : public CCommNotifyBase

	{

public:

	CCommAvailableDataNotifier(CHWPort* aParent);

	~CCommAvailableDataNotifier();

	// from CActive

	virtual void DoCancel();

	virtual void RunL();

	//

	void Start();

	};

/**

 * this class is responsible for notifying the client when

 * the flow control is changing.

 */

class CCommFlowControlChangeNotifier : public CCommNotifyBase

	{

public:

	CCommFlowControlChangeNotifier(CHWPort* aParent);

	~CCommFlowControlChangeNotifier();

	// from CActive

	virtual void DoCancel();

	virtual void RunL();

	//

	void Start();

private:

	TFlowControl iFlowControl; //< current flow control settings

	};

/**

 * this class is responsible for notifying the client when

 * the configuration is changing.

 */

class CCommConfigChangeNotifier : public CCommNotifyBase

	{

public:

	CCommConfigChangeNotifier(CHWPort* aParent);

	~CCommConfigChangeNotifier();

	void Start();

	// from CActive

	virtual void DoCancel();

	virtual void RunL();

private:

	TCommNotificationPckg iConfig; //< current configuration package

	};

/**

 * CPort is the object which interfaces to the commserver

 */

class CHWPort : public CPort

	{

public:

	static CHWPort* NewL(TUint aUnit);

private:

	 CHWPort();

public:

	virtual void StartRead(const TAny* aClientBuffer,TInt aLength);

	virtual void ReadCancel();

	virtual TInt QueryReceiveBuffer(TInt& aLength) const;

	virtual void ResetBuffers(TUint aFlags);

	virtual void StartWrite(const TAny* aClientBuffer,TInt aLength);

	virtual void WriteCancel();

	virtual void Break(TInt aTime);

	virtual void BreakCancel();

	virtual TInt GetConfig(TDes8& aDes) const;

	virtual TInt SetConfig(const TDesC8& aDes);

	virtual TInt SetServerConfig(const TDesC8& aDes);

	virtual TInt GetServerConfig(TDes8& aDes);

	virtual TInt GetCaps(TDes8& aDes);

	virtual TInt GetSignals(TUint& aSignals);

	virtual TInt SetSignalsToMark(TUint aSignals);

	virtual TInt SetSignalsToSpace(TUint aSignals);

	virtual TInt GetReceiveBufferLength(TInt& aLength) const;

	virtual TInt SetReceiveBufferLength(TInt aSignals);

	virtual void Destruct();

	virtual void FreeMemory();

	virtual void NotifySignalChange(TUint aSignalMask);

	virtual void NotifySignalChangeCancel();

	virtual void NotifyConfigChange();

	virtual void NotifyConfigChangeCancel();

	virtual void NotifyFlowControlChange();

	virtual void NotifyFlowControlChangeCancel();

	virtual void NotifyBreak();

	virtual void NotifyBreakCancel();

	virtual void NotifyDataAvailable();

	virtual void NotifyDataAvailableCancel();

	virtual void NotifyOutputEmpty();

	virtual void NotifyOutputEmptyCancel();

	virtual TInt GetFlowControlStatus(TFlowControl& aFlowControl);

	virtual TInt GetRole(TCommRole& aRole);

	virtual TInt SetRole(TCommRole aRole);

	virtual ~CHWPort();

#if defined (_DEBUG_DEVCOMM)

	virtual void DoDumpDebugInfo(const RMessage2 &aMessage);

#endif

	RBusDevComm& DTEPort();

	RBusDevCommDCE& DCEPort();

private:

	CCommReader* iReader;                                       //< pointer to the Active Reader

	CCommWriter* iWriter;                                       //< pointer to the Active Writer

	CCommBreaker* iBreaker;                                     //< pointer to the Active Breaker

	CCommSignalNotifier* iSignalNotifier;                       //< pointer to the Active Signal Notifier

	CCommAvailableDataNotifier* iDataAvailableNotifier;         //< pointer to the Active Data available notifier

	CCommFlowControlChangeNotifier* iFlowControlChangeNotifier; //< pointer to the Active Flow Control notifier

	CCommConfigChangeNotifier* iConfigChangeNotifier;           //< pointer to the Active Config Change notifier

	RBusDevComm iPort;           //< interface to the logical Comm port device (DTE role)

	RBusDevCommDCE iPortDCE;     //< interface to the logical Comm port device (DCE role)

	TCommRole iRole;             //< DTE or DCE role for this port unit

	TUint iPortName;             //< contains the port unit number (i.e. 0 for COMM::0)

	TBool iEarlyWriteCompletion; //< ETrue if early write completion enabled

#if defined (_DEBUG_CONSOLE_)

#if defined (_DEBUG_DEVCOMM)

	CCommDebugDumper *iDumper;

#endif

public:

	RDebugConsole iConsole;

#endif

	};

/**

 * "Entry point object" makes the objects which do the work

 */

class CHWPortFactory : public CSerial

	{

public:

    CHWPortFactory();

	virtual CPort* NewPortL(const TUint aUnit);

	virtual void Info(TSerialInfo &aSerialInfo);

public:	//from CSerial

	TSecurityPolicy PortPlatSecCapability(TUint aPort) const;

	};

/**

 * this class handles the 'Read one or more' method

 * for ports with role DTE

 */

class RMaxComm : public RBusDevComm

	{

public:

	static void ReadOneOrMore(RBusDevComm& aComm, TRequestStatus& aStatus, TDes8& aDes, TInt aLen);

	};

void RMaxComm::ReadOneOrMore(RBusDevComm& aComm, TRequestStatus& aStatus, TDes8& aDes, TInt aLen)

/**

 * reads one or more bytes from the physical DTE com port

 *

 * @param aComm   handle to the logical com port device

 * @param aStatus handle for asyncronous communications

 * @param aDes    buffer to be read into

 * @param aLen    max number of bytes to read

 */

    {

	LOGECUART2(_L8("RMaxComm::ReadOneOrMore(), (max. bytes to read) aLen = %d"), aLen);

	RMaxComm& r = (RMaxComm&)aComm;

	aLen = -aLen; // Note: negative length here means ReadOneOrMore

	              //       see RComm::ReadOneOrMore in CC_CLI.CPP

	r.DoRequest(ERequestRead, aStatus, &aDes, &aLen);

    }

/**

 * this class handles the 'Read one or more' method

 * for ports with role DCE

 */

class RMaxCommDCE : public RBusDevCommDCE

	{

public:

	static void ReadOneOrMore(RBusDevCommDCE& aComm, TRequestStatus& aStatus, TDes8& aDes, TInt aLen);

	};

void RMaxCommDCE::ReadOneOrMore(RBusDevCommDCE& aComm, TRequestStatus& aStatus, TDes8& aDes, TInt aLen)

/**

 * reads one or more bytes from the physical DCE com port

 *

 * @param aComm   handle to the logical com port device

 * @param aStatus handle for asyncronous communications

 * @param aDes    buffer to be read into

 * @param aLen    max number of bytes to read

 */

    {

	LOGECUART2(_L8("RMaxCommDCE::ReadOneOrMore(), (max. bytes to read) aLen = %d"), aLen);

	RMaxCommDCE& r = (RMaxCommDCE&)aComm;

	aLen = -aLen; // Note: negative length here means ReadOneOrMore

	              //       see RComm::ReadOneOrMore in CC_CLI.CPP

	r.DoRequest(ERequestRead, aStatus, &aDes, &aLen);

    }

void Fault(TCommFault aFault)

/**

 * Panic the comm module (us)

 *

 * @param aFault Panic code

 */

	{

	LOGECUART3(_L8("Fault(), (TCommFault) aFault = %d (%S)"), aFault, &TECUARTLOG::CommFaultStr(aFault));

	_LIT(KCsyPanicCategory, "CHWComm" );

	User::Panic(KCsyPanicCategory, aFault);

	}

//

// implementation of CCommReadWriteBase

//

CCommReadWriteBase::CCommReadWriteBase(TInt aPriority, CHWPort* aParent)

/**

 * C'tor

 *

 * @param aPriority priority of the Active Object

 * @param aParent   pointer to the owner, the CHWPort object

 */

	:CActive(aPriority)

	,iBufSize(KDefaultBufSize)

	,iRole(ECommRoleDTE)

	,iParent(aParent)

	{

	LOGECUART1(_L8("CCommReadWriteBase::CCommReadWriteBase()"));

	}