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

// Evil communications corrupt good manners. 

// 1 corinthians  xv. 33.

// 

//

#include <k32std.h>

#include "d_comm.h"

#include <e32hal.h>

const TInt KIdleTimeoutPeriod=20*1000000;  // 20 seconds

const TUint KXoffSignal=0x80000000;

//

const TInt KInputHeldFree=(-1);

const TInt KInputHeld=(-2);

//

const TUint KTransmitting=0x01;

const TUint KBreaking=0x02;

const TUint KBreakPending=0x04;

//

enum TPanic

	{

	ESetConfigWhileRequestPending,

	ESetSignalsSetAndClear,

	EResetBuffers,

	ESetReceiveBufferLength,

//	EDoubleTxBufFill,

	};

EXPORT_C DLogicalDevice *CreateLogicalDevice()

//

// Create a new device

//

	{

	return(new DDeviceComm);

	}

DDeviceComm::DDeviceComm()

//

// Constructor

//

	{

	iParseMask=KDeviceAllowAll;

	iUnitsMask=0xffffffff; // Leave units decision to the driver

	iVersion=TVersion(KCommsMajorVersionNumber,KCommsMinorVersionNumber,KCommsBuildVersionNumber);

	}

TInt DDeviceComm::Install()

//

// Install the device driver.

//

	{

    TPtrC name=_L("Comm");

	return(SetName(&name));

	}

void DDeviceComm::GetCaps(TDes8 &aDes) const

//

// Return the Comm capabilities.

//

	{

	TCapsDevCommV01 b;

	b.version=iVersion;

	aDes.FillZ(aDes.MaxLength());

	aDes.Copy((TUint8 *)&b,Min(aDes.MaxLength(),sizeof(b)));

	}

DLogicalChannel *DDeviceComm::CreateL()

//

// Create a channel on the device.

//

	{

	return(new(ELeave) DChannelComm(this));

	}

TInt DChannelComm::CallDfc(TAny* aDChannelComm)

//

// Dfc call back - cast the pointer to a DChannel comm and call DoDfc

//

	{

	((DChannelComm *)aDChannelComm)->DfcHandler();

	return KErrNone;

	}

//

// Comms power handler

//

// Active tx requests keep power requirement up.

// Completed tx requests keep power requirement up for KIdleTimeoutPeriod.

// Rx requests don't effect power requirement

// 

DCommPowerHandler::DCommPowerHandler(DChannelComm *aLdd) : iLdd(aLdd)

	{}

void DCommPowerHandler::RequestPending()

//

// Tx request made

//

	{

	iTimer.Cancel();

	if (iRequirement == 0)

		SetRequirement(1); /* EPowerCpu */

	}

void DCommPowerHandler::RequestComplete()

//

// Tx request completed, set the timer

//

	{

	iTimer.Cancel();

	iTimer.OneShotInMicroSeconds(TTimeIntervalMicroSeconds32(KIdleTimeoutPeriod), DCommPowerHandler::Timeout, this);

	}

void DCommPowerHandler::Timeout(TAny *aHandler, TInt)

//

// Timeout following last Tx request (in DFC)

//

	{

	DCommPowerHandler& handler=*(DCommPowerHandler*)aHandler;

	handler.SetRequirement(0);  // EPowerNone

	handler.iLdd->DoPowerDown(); 

	handler.iLdd->ResetDevice();

	handler.iLdd->CompleteAll(KErrAbort); // Complete all outstanding client requests

	}

TInt DCommPowerHandler::DoPowerOn()

//

// Machine power up event

// Serial driver ignores machine power up events and instead powers up the

// device in response to user requests 

//

	{

	return(KErrNone);

	}

void DCommPowerHandler::DoPowerEmergencyStandby()

//

// Machine emergency power down event

// Can't ignore these events - need to power down the device

//

	{

	iLdd->DoEmergencyPowerDown();

	}

void DCommPowerHandler::DoPowerStandby()

//

// Machine normal power down event

// Serial driver ignores machine normal power down events and instead uses an

// inactivity timer on Tx requests to control power down.

//

	{

	}

#pragma warning( disable : 4705 )	// statement has no effect

#pragma warning( disable : 4355 )	// this used in intializer list

DChannelComm::DChannelComm(DLogicalDevice *aDevice)

//

// Constructor

//

: DLogicalChannel(aDevice), iDfc(TCallBack(DChannelComm::CallDfc,this))

	{

//

// Require power notifications and 3 valid requests

//

	SetBehaviour(RBusDevComm::ERequestReadCancel|RBusDevComm::ERequestWriteCancel|RBusDevComm::ERequestBreakCancel|RBusDevComm::ERequestNotifySignalChangeCancel);

//

// Setup the default config

//

	iConfig.iRate=EBps9600;

	iConfig.iDataBits=EData8;

	iConfig.iStopBits=EStop1;

	iConfig.iParity=EParityNone;

	iConfig.iFifo=EFifoEnable;

	iConfig.iHandshake=KConfigObeyCTS;

	iConfig.iParityError=KConfigParityErrorFail;

	iConfig.iSIREnable=ESIRDisable;

//	iConfig.iTerminatorCount=0;

//	iConfig.iTerminator[0]=0;

//	iConfig.iTerminator[1]=0;

//	iConfig.iTerminator[2]=0;

//	iConfig.iTerminator[3]=0;

	iConfig.iXonChar=0x11; // XON

	iConfig.iXoffChar=0x13; // XOFF

//	iConfig.iSpecialRate=0;

//	iConfig.iParityErrorChar=0;

//	iDriver=NULL;

	iStatus=ENotActive;

	iInputHeld=KInputHeldFree;

//	iOutputHeld=0;

//	iReceiveOneOrMore=0;

//	iReceiveError=0;

//	iReceiveErrorLength=0;

//	iReceiveLength=0;

//	iReceiveOffset=0;

//	iTransmitLength=0;

//	iTransmitOffset=0;

//	iFlags=0;

//	iSignals=0;

//	iLowWaterMark=0;

//	iHighWaterMark=0;

//	iHalfFullMark=0;

//	iReceivePtr=NULL;

//	iTransmitPtr=NULL;

//	iRxBuf=NULL;

//	iTxBuf=NULL;

//	iIsReading=EFalse;

//	iIsWriting=EFalse;

//	iDrainingRxBuf=EFalse;

//	iFillingTxBuf=EFalse;

//	iRunningDfc=EFalse;

//	iSignalChangeNotification=EFalse;

//	iSignalChangePtr=NULL;

//	iSignalMask=0;

//  iSignalChangeInfo=0;

//	iDataAvailableNotification=EFalse;

	}

#pragma warning( default : 4705 )

#pragma warning( disable : 4355 )

DChannelComm::~DChannelComm()

//

// Destructor

//

	{

	// Complete any outstanding requests

	CompleteAll(KErrAbort);

	// Power down h/w, disable interrupts

	iPowerHandler->iTimer.Cancel();

	iPowerHandler->PowerStandby();  	// Doesn't do anything in inactivity power policy case, hence DoPowerDown() call below.

	DoPowerDown(); 

	// clean up the power handler

//	iPowerHandler->SetRequirement(0);	// No need for this, done in DoPowerDown().

	Power::RemovePowerHandler(*iPowerHandler);

	delete iPowerHandler;

	TInt clearMask=0;

	if (!(iConfig.iHandshake&KConfigFreeRTS))

		clearMask|=KSignalRTS;

	if (!(iConfig.iHandshake&KConfigFreeDTR))

		clearMask|=KSignalDTR;

	iDriver->SetSignals(0,clearMask);

	delete iDriver;

	delete iRxBuf;

	delete iTxBuf;

	}

void DChannelComm::DoCreateL(TInt /*aUnit*/,CBase *aDriver,const TDesC * /*anInfo*/,const TVersion &aVer)

//

// Create the channel from the passed info.

//

	{

	iDriver=(DComm *)aDriver; // Must do this to ensure the driver is destroyed by the destructor

	if (!User::QueryVersionSupported(TVersion(KCommsMajorVersionNumber,KCommsMinorVersionNumber,KCommsBuildVersionNumber),aVer))

		User::Leave(KErrNotSupported);

	// get power managed

	iPowerHandler=new (ELeave) DCommPowerHandler(this);

	User::LeaveIfError(Power::AddPowerHandler(*iPowerHandler));

//	iRxBuf=new(ELeave) CCirBuf<TInt>;

//	iTxBuf=new(ELeave) CCirBuffer;

	iTxBuf=new(ELeave) CCommTxBuf;

	iRxBuf=new(ELeave) CCommRxBuf;

	User::LeaveIfError(SetRxBufferSize(KDefaultRxBufferSize));

	iTxBuf->SetLengthL(KTxBufferSize);

	((DComm *)aDriver)->SetComm(this); // Rog

	iDriver->CheckConfig(iConfig);

	StateIsr(iDriver->Signals());

	iPowerHandler->PowerOn();	// Ask the PowerManager to power us up

	}

void DChannelComm::DfcHandler()

//

// Called as a Dfc. Handles all buffer draining and filling and message completions.

//

	{	

	iDriver->DisableInterrupts();

	while (iDfcRequest!=0)

		{

		if (iDfcRequest & EDrainRxBufferRequired)

			{

#ifdef _DEBUG_DEVCOMM

			iDfcHandlerSeq = iRxBuf->iRemSeqNum.Int();

#endif

			iDfcRequest &= ~EDrainRxBufferRequired;

			iDriver->EnableInterrupts();

			if (!iDrainingRxBuf)

				DoDrainRxBuffer();

			iDriver->DisableInterrupts();

			continue;

			}

		if (iDfcRequest & ECompleteWrite)

			{

			iDfcRequest &= ~ECompleteWrite;

			iDriver->EnableInterrupts();

			if (iIsWriting)

				{

				iIsWriting = EFalse;

				iWriteZero = EFalse;

				if (iIsClientWriting)

					Complete(RBusDevComm::ERequestWrite,iWriteError);

				iIsClientWriting = EFalse;

				iWriteError = KErrNone;

				}

			iDriver->DisableInterrupts();

			continue;

			}

		else if (iDfcRequest & EEarlyCompleteWrite)

			{

			iDfcRequest &= ~EEarlyCompleteWrite;

			iDriver->EnableInterrupts();

			if (iIsClientWriting)

				{

				iIsClientWriting = EFalse;

				Complete(RBusDevComm::ERequestWrite,iWriteError);

				iWriteError = KErrNone;

				}

			iDriver->DisableInterrupts();

			continue;

			}

		if (iDfcRequest & ECompleteEmergency)

			{

			iDfcRequest &= ~ECompleteEmergency;

			ResetDevice();

			CompleteAll(KErrBadPower);

			continue;

			}

		if (iDfcRequest & EFillTxBufferRequired)

			{

			iDfcRequest &= ~EFillTxBufferRequired;

			iDriver->EnableInterrupts();

			if (!iFillingTxBuf)

				DoFillTxBuffer();

			iDriver->DisableInterrupts();

			continue;

			}

		if (iDfcRequest & ECompleteSignalChange)

			{

			iDfcRequest &= ~ECompleteSignalChange;

    		iThread->Write(iSignalChangePtr,(TUint8*)&iSignalChangeInfo,(TInt)sizeof(TUint));

			iSignalChangeNotification=EFalse;

			Complete(RBusDevComm::ERequestNotifySignalChange);

			continue;

			}

		if (iDfcRequest & ECompleteDataAvailable)

			{

			iDfcRequest &= ~ECompleteDataAvailable;

			iDataAvailableNotification=EFalse;

			Complete(RBusDevComm::ERequestRead);

			continue;

			}

		}

#ifdef _DEBUG_DEVCOMM

	--iDfcCount;

#endif

	iRunningDfc=EFalse;

	iPowerHandler->RequestComplete();

	iDriver->EnableInterrupts();

	}

void DChannelComm::RestoreDtrRrs()

//

// Check if driver is configured not to auto control RTS/DTR and restore state

// of these signals acording to current config. (as specified by driver

// client) if necessary

//

	{

	TUint hand=iConfig.iHandshake;

	if ((hand&KConfigFreeRTS))

		{

		if (iSignals&KSignalRTS)

			iDriver->SetSignals(KSignalRTS,0);

		else

			iDriver->SetSignals(0,KSignalRTS);

		}

	if (!iPowerHandler->PowerGood())

		return;

	if (hand&KConfigFreeDTR)

		{

		if (iSignals&KSignalDTR)

			iDriver->SetSignals(KSignalDTR,0);

		else

			iDriver->SetSignals(0,KSignalDTR);

		}

	}

void DChannelComm::Start()

//

// Start the driver receiving.

//

	{

	// If waiting for driver to be closed then just return

	if (iStatus==EClosed)

		return;

	if (iStatus!=EActive)

		ResetBuffers();	// Reset RX/TX buffers

	iDriver->Configure(iConfig);

	iDriver->Start();

	if (iConfig.iHandshake & KConfigSendXoff && iInputHeld>=0)

		EnableTransmit(); // Send XOn if there is one

	if (iStatus!=EActive)

		{

		// If driver configured not to auto control RTS/DTR then restore state of

		// these signals acording to current config. (as specified by driver client).

		TUint hand=iConfig.iHandshake;

		if (hand&(KConfigFreeRTS|KConfigFreeDTR))

			RestoreDtrRrs();

		}

	iStatus=EActive;

	}

void DChannelComm::Stop(TStopMode aMode)

//

// Stop the driver.

//

	{

	iDriver->Stop(aMode);

	}

void DChannelComm::BreakOn()

//

// Start the driver breaking.

//

	{

	if (iFlags&KTransmitting)

		iFlags|=KBreakPending;

	else

		{

		iFlags&=(~KBreakPending);

		iFlags|=KBreaking;

		iDriver->Break(ETrue);

		}

	}

void DChannelComm::BreakOff()

//

// Stop the driver breaking.

//

	{

	iDriver->Break(EFalse);

	iFlags&=(~(KBreakPending|KBreaking));

	}

void DChannelComm::EnableTransmit()

//

// Make sure we are transmitting

//

	{

	if ((iFlags & KTransmitting)==0)

		{

		iFlags |= KTransmitting; // Signal the fact the we are transmitting

		iDriver->EnableTransmit(); // Start transmitting

		}

	}

TInt DChannelComm::SetRxBufferSize(TInt aSize)

//

// Set the receive buffer size.

//

	{

	TRAPD(r,iRxBuf->SetLengthL(aSize));

	if (r==KErrNone)

		{

		iLowWaterMark=(aSize>>2); // 25 %

		iHalfFullMark=(aSize>>1); // 50 %

		if (iConfig.iParityError & KConfigXonXoffDebug)

			{

			iHighWaterMark=iHalfFullMark-5;

			}

		else

			iHighWaterMark=aSize-iLowWaterMark; // 75%

		}

	return(r);

	}

void DChannelComm::ResetBuffers()

//

// Reset the receive and transmit buffers.

//

	{

	iIsWriting=EFalse;

	iRxBuf->Reset();

	iTxBuf->Reset();

	iReceiveError=KErrNone;

	if (iStatus==EActive)

		{

		if ((iConfig.iHandshake & KConfigFreeRTS)==0)

            iDriver->SetSignals(KSignalRTS,0); // Assert RTS

		if ((iConfig.iHandshake & KConfigFreeDTR)==0)

            iDriver->SetSignals(KSignalDTR,0); // Assert DTR

        if (iConfig.iHandshake&KConfigSendXoff) // Doing input XON/XOFF

            {

            iInputHeld=iConfig.iXonChar; // set up to send Xon

			EnableTransmit(); // Make sure we are transmitting

            }

		else

			iInputHeld=KInputHeldFree;