// 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:

// wins/specific/serialldd.cpp

// 

//

#include "winscomm.h"

#include <kernel/kern_priv.h>

#include <e32hal.h>

#include <e32uid.h>

_LIT(KLddName,"Comm");

const TUint KBreaking=0x02;

const TUint KBreakPending=0x04;

enum TPanic

	{

	ESetConfigWhileRequestPending,

	ESetSignalsSetAndClear,

	EResetBuffers,

	ESetReceiveBufferLength,

	};

inline TUint32 SafeSwap(TUint32 aNewValue, TUint32& aWord)

	{ return __e32_atomic_swp_ord32(&aWord, aNewValue); }

DECLARE_STANDARD_LDD()

	{

	return new DDeviceComm;

	}

DDeviceComm::DDeviceComm()

	{

	iParseMask = KDeviceAllowAll;

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

	iVersion = TVersion(KCommsMajorVersionNumber,KCommsMinorVersionNumber,KCommsBuildVersionNumber);

	}

TInt DDeviceComm::Install()

	{

	return(SetName(&KLddName));

	}

void DDeviceComm::GetCaps(TDes8& aDes) const

	{

	TPckgBuf<TCapsDevCommV01> b;

	b().version = TVersion(KCommsMajorVersionNumber,KCommsMinorVersionNumber,KCommsBuildVersionNumber);

	Kern::InfoCopy(aDes,b);

	}

TInt DDeviceComm::Create(DLogicalChannelBase*& aChannel)

	{

	aChannel = new DChannelComm;

	return aChannel?KErrNone:KErrNoMemory;

	}

DChannelComm::DChannelComm()

	:

		iRxCompleteDfc(DChannelComm::CompleteRxDfc,this,2),

		iTxCompleteDfc(DChannelComm::CompleteTxDfc,this,2),

		iRxDataAvailableDfc(DChannelComm::RxDataAvailableDfc,this,2),

		iSigNotifyDfc(DChannelComm::SignalNotifyDfc,this,2),

//		iBreakMinMilliSeconds(0),

//		iTurnaroundTimerRunning(EFalse),

//		iTurnaroundTransmitDelayed(EFalse),

		iTurnaroundTimer(DChannelComm::TurnaroundStartDfc, this),

		iTurnaroundDfc(DChannelComm::TurnaroundTimeout, this, 2),

//		iTurnaroundTxDesPtr(0),

//		iTurnaroundTxDesLength(0)

		iBreakDfc(DChannelComm::FinishBreakDfc, this, 2)

	{

	iConfig.iRate = EBps9600;

	iConfig.iDataBits = EData8;

	iConfig.iStopBits = EStop1;

	iConfig.iParity = EParityNone;

	iConfig.iHandshake = KConfigObeyCTS;

	iConfig.iParityError = KConfigParityErrorFail;

	iConfig.iFifo = EFifoEnable;

	iConfig.iTerminatorCount = 0;

	iConfig.iXonChar = 0x11;

	iConfig.iXoffChar = 0x13;

	iConfig.iSIREnable = ESIRDisable;

	iTxError = KErrNone;

	iRxError = KErrNone;

	iRxDAError = KErrNone;

	iSignalError = KErrNone;

	iClientDestPtr = 0;

	iClientSignalResultPtr = 0;

	iClient = &Kern::CurrentThread();

	iClient->Open();

	}

DChannelComm::~DChannelComm()

	{

	Kern::SafeClose((DObject*&)iClient, NULL);

	}

void DChannelComm::Shutdown()

	{

	// clean-up...

	if (iStatus == EActive)

		Stop(EStopPwrDown);			// stop PDD

	Complete(EAll, KErrAbort);

	iRxCompleteDfc.Cancel();

	iTxCompleteDfc.Cancel();

	iTurnaroundTimer.Cancel();

	iTurnaroundDfc.Cancel();

	iSigNotifyDfc.Cancel();

	iRxDataAvailableDfc.Cancel();

	iBreakTimer.Cancel();

	iBreakDfc.Cancel();

	}

TInt DChannelComm::TurnaroundSet(TUint aNewTurnaroundMilliSeconds)

	{

	TInt r = KErrNone;

	iTurnaroundMinMilliSeconds = aNewTurnaroundMilliSeconds;

	return r;

	}

TBool DChannelComm::TurnaroundStopTimer()

// Stop the timer and DFC

	{

	TInt irq = 0;

	irq = NKern::DisableInterrupts(1);

	TBool result = iTurnaroundTimerRunning;

	if(result)

		{

		iTurnaroundTimerRunning = EFalse;

		iTurnaroundTimer.Cancel();

		iTurnaroundDfc.Cancel();

		}

	NKern::RestoreInterrupts(irq);

	return result;

	}

TInt DChannelComm::TurnaroundClear()

// Clear any old timer and start timer based on new turnaround value.

// Called for any change: from T > 0 to T == 0 or (T = t1 > 0) to (T = t2 > 0)

// POLICY: If a write has already been delayed, it will be started immediately if the requested 

//  turnaround time is elapsed else will only start after it is elapsed.

	{

	TInt r = KErrNone;

	TUint delta = 0;

    if(iTurnaroundTimerStartTimeValid == 1)

		{

		//Calculate the turnaround time elapsed so far

		delta = (NKern::TickCount() - iTurnaroundTimerStartTime) * NKern::TickPeriod();

		}

	if(delta < iTurnaroundMicroSeconds)

		{

        iTurnaroundMinMilliSeconds = (iTurnaroundMicroSeconds - delta) / 1000;

      	TInt irq = NKern::DisableInterrupts(1);

		// POLICY: if timer is running from a previous read, stop it and re-start it

		if(iTurnaroundTimerRunning)

			{

			iTurnaroundTimer.Cancel();

			iTurnaroundDfc.Cancel();

			}

		iTurnaroundTimerRunning = ETrue;

		TInt timeout = NKern::TimerTicks(iTurnaroundMinMilliSeconds);

		iTurnaroundTimer.OneShot(timeout);

    	NKern::RestoreInterrupts(irq);

	    }

    else

		{

		if(TurnaroundStopTimer())

			{

			// if a write is waiting, start a DFC to run it

			TurnaroundStartDfcImplementation(EFalse);

			}

		}

	iTurnaroundMinMilliSeconds = 0;

	return r;

	}

void DChannelComm::TurnaroundStartDfc(TAny* aSelf)

	{

	DChannelComm* self = (DChannelComm*)aSelf;

	self->TurnaroundStartDfcImplementation(ETrue);

	}

void DChannelComm::TurnaroundStartDfcImplementation(TBool inIsr)

	{

	TInt irq = 0;

	if(!inIsr)

		{

		irq = NKern::DisableInterrupts(1);

		}

	iTurnaroundTimerRunning = EFalse;

	if(iTurnaroundTransmitDelayed || iTurnaroundBreakDelayed)

		{

		if(inIsr)

			iTurnaroundDfc.Add();

		else

			{

			NKern::RestoreInterrupts(irq);

			iTurnaroundDfc.Enque();

			}

		return;

		}

	if(!inIsr)

		{

		NKern::RestoreInterrupts(irq);

		}

	}

void DChannelComm::TurnaroundTimeout(TAny* aSelf)

	{

	DChannelComm* self = (DChannelComm*)aSelf;

	self->TurnaroundTimeoutImplementation();

	}

void DChannelComm::TurnaroundTimeoutImplementation(void)

	{

	TInt irq = NKern::DisableInterrupts(1);

	if (iTurnaroundBreakDelayed)

		{

		iTurnaroundBreakDelayed=EFalse;

		if (iStatus==EClosed)

			{

            NKern::RestoreInterrupts(irq);

			Complete(EBreak, KErrNotReady);

			return;

			}

		if (LineFail())

			{

            NKern::RestoreInterrupts(irq);

			Complete(EBreak, KErrCommsLineFail);

			return;

			}

		if (iTurnaroundTransmitDelayed)

			{

			//delay write by break instead of turnaround

			iBreakDelayedTx = ETrue;

			iBreakDelayedTxDesPtr = iTurnaroundTxDesPtr;

			iBreakDelayedTxDesLength = iTurnaroundTxDesLength;

			iTurnaroundTxDesPtr=0;

			iTurnaroundTxDesLength=0;

			iTurnaroundTransmitDelayed=EFalse;

			}

        NKern::RestoreInterrupts(irq);

		BreakOn();

		}

	else if(iTurnaroundTransmitDelayed)

		{

		iTurnaroundTransmitDelayed = EFalse;	// protected -> prevent reentrant ISR

		NKern::RestoreInterrupts(irq);

		if (iStatus==EClosed)

			{

			iTurnaroundTxDesPtr = 0;

			iTurnaroundTxDesLength = 0;

			Complete(ETx,KErrNotReady);

			return;

			}

		// fail signals checked in the PDD

		InitiateWrite(iTurnaroundTxDesPtr, iTurnaroundTxDesLength);

		iTurnaroundTimerStartTime = 0;

		iTurnaroundTimerStartTimeValid = 2;

		iTurnaroundTxDesPtr = 0;

		iTurnaroundTxDesLength = 0;

		}

	else 

		NKern::RestoreInterrupts(irq);

	}

TInt DChannelComm::DoCreate(TInt aUnit, const TDesC8* /*aInfo*/, const TVersion &aVer)

	{

	if(!Kern::CurrentThreadHasCapability(ECapabilityCommDD,__PLATSEC_DIAGNOSTIC_STRING("Checked by ECOMM.LDD (Comm Driver)")))

		return KErrPermissionDenied;

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

		return KErrNotSupported;

	// set up the correct DFC queue

	SetDfcQ(((DComm*)iPdd)->DfcQ(aUnit));

	iRxCompleteDfc.SetDfcQ(iDfcQ);

	iTxCompleteDfc.SetDfcQ(iDfcQ);

	iRxDataAvailableDfc.SetDfcQ(iDfcQ);

	iSigNotifyDfc.SetDfcQ(iDfcQ);

	iTurnaroundDfc.SetDfcQ(iDfcQ);

	iBreakDfc.SetDfcQ(iDfcQ);

	iMsgQ.Receive();

	((DComm *)iPdd)->iLdd = this;

	//setup the initial port configuration

	PddConfigure(iConfig);

	return KErrNone;

	}

void DChannelComm::Start()

	{

	if (iStatus != EClosed)

		{

		PddStart();

		iStatus = EActive;

		}

	}

void DChannelComm::HandleMsg(TMessageBase* aMsg)

	{

	TThreadMessage& m = *(TThreadMessage*)aMsg;

	TInt id = m.iValue;

	if (id == (TInt)ECloseMsg)

		{

		Shutdown();

		iStatus = EClosed;

		m.Complete(KErrNone, EFalse);

		return;

		}

	else if (id == KMaxTInt)

		{

		// DoCancel

		DoCancel(m.Int0());

		m.Complete(KErrNone, ETrue);

		return;

		}

	if (id < 0)

		{

		// DoRequest

		TRequestStatus* pS = (TRequestStatus*)m.Ptr0();

		TInt r = DoRequest(~id, pS, m.Ptr1(), m.Ptr2());

		if (r != KErrNone)

			Kern::RequestComplete(iClient, pS, r);

		m.Complete(KErrNone, ETrue);

		}

	else

		{

		// DoControl

		TInt r = DoControl(id, m.Ptr0(), m.Ptr1());

		m.Complete(r, ETrue);

		}

	}

TInt DChannelComm::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)

	{

	//

	// First check if we have started

	//

	if (iStatus == EOpen)

		{

		Start();

		}

	// Now we can dispatch the request

	TInt r = KErrNone;

	TInt len = 0;

	switch (aReqNo)

		{

		case RBusDevComm::ERequestRead:

			if (a2)

				//get the size of the client data 

				r = Kern::ThreadRawRead(iClient, a2, &len, sizeof(len));

			if (r == KErrNone)

				{

				if (a1)	//doing a read

					{

					iRxStatus = aStatus;

					//start the read

					InitiateRead(a1,len);

					}

				else	//notify read data availiable

					{

					iRxDAStatus = aStatus;

					NotifyReadDataAvailable();

					}

				}

			break;

		case RBusDevComm::ERequestWrite:

			{

			if (iStatus == EClosed)

				return KErrNotReady;

			if (!a1)

				a1 = (TAny*)1;

			r = Kern::ThreadRawRead(iClient, a2, &len, sizeof(len));	//get the length of the data to write

			if (r == KErrNone)

				{

				iTxStatus = aStatus;

				TInt irq = NKern::DisableInterrupts(1);

				if(iTurnaroundTimerRunning)

					{

					iTurnaroundTransmitDelayed = ETrue;

					iTurnaroundTxDesPtr = a1;

					iTurnaroundTxDesLength = len;

					NKern::RestoreInterrupts(irq);

					}

				else if (iFlags & KBreaking)

					{

					// currently breaking, delay the write

					iBreakDelayedTx = ETrue;

					iBreakDelayedTxDesPtr = a1;		// save these as client could could start trashing them before the

					iBreakDelayedTxDesLength = len;	// transmission effectively starts

					NKern::RestoreInterrupts(irq);

					}

				else

					{

					NKern::RestoreInterrupts(irq);

					InitiateWrite(a1, len); //a1 is ptr to data to write (on client side)

					iTurnaroundTimerStartTime = 0;

					iTurnaroundTimerStartTimeValid = 2;

					}

				}

			break;

			}

		case RBusDevComm::ERequestNotifySignalChange:

			{

			//a1 has place to put the result

			//a2 has the signal mask

			if (!a1)

				{

				r = KErrArgument;

				break;

				}

			//start the signal request

			TInt mask = 0;

			r = Kern::ThreadRawRead(iClient, a2, &mask, sizeof(mask));	//get the signal mask

			if (r == KErrNone)

				{

				iSignalStatus = aStatus;

				InitiateNotifySignals(a1, mask);

				}

			break;

			}

		case RBusDevComm::ERequestBreak:

			{

			r = Kern::ThreadRawRead(iClient, a1, &iBreakTimeMicroSeconds, sizeof(TInt));	//get the time to break for

			if (r == KErrNone)

				{

				iBreakStatus=aStatus;

				// check if turnaround timer running.

				TInt irq = NKern::DisableInterrupts(1);

				if(iTurnaroundTimerRunning)

					{

					iTurnaroundBreakDelayed = ETrue;

					NKern::RestoreInterrupts(irq);

					}

				else

					{

					NKern::RestoreInterrupts(irq);

					BreakOn();

					}

				}

			break;

			}

		default:

			r = KErrNotSupported;

			break;

		}

	return r;

	}

TInt DChannelComm::SetConfig(TCommConfigV01& c)

	{

	iConfig = c;

	PddConfigure(iConfig);

	return KErrNone;

	}

TInt DChannelComm::DoControl(TInt aFunction, TAny* a1, TAny* a2)

	{

	TCommConfigV01 c;

	TInt r = KErrNone;

	switch (aFunction)

		{

		case RBusDevComm::EControlConfig:

			{

			//get the current configuration

			TPtrC8 cfg((const TUint8*)&iConfig, sizeof(iConfig));

			r = Kern::ThreadDesWrite(iClient, a1, cfg, 0, KTruncateToMaxLength, iClient);

			break;

			}

		case RBusDevComm::EControlSetConfig:

			{

			if (AreAnyPending())	

				Kern::PanicCurrentThread(_L("D32COMM"), ESetConfigWhileRequestPending);

			else

				{

				memclr(&c, sizeof(c));

				TPtr8 cfg((TUint8*)&c, 0, sizeof(c));

				r = Kern::ThreadDesRead(iClient, a1, cfg, 0, 0);

				if (r == KErrNone)

					r = SetConfig(c);	//set the new configuration

				}

			break;