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

			}

		case RBusDevComm::EControlCaps:

			{

			//get capabilities

			TCommCaps2 caps;

			PddCaps(caps);	//call ipdd->Caps

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

			break;

			}

		case RBusDevComm::EControlSignals:

			{

			r = Signals();

			break;

			}

		case RBusDevComm::EControlSetSignals:

			{

//			if (((TUint)a1)&((TUint)a2))	//can't set and clear at same time

//				{

//				Kern::PanicCurrentThread(_L("D32COMM"), ESetSignalsSetAndClear);

//				}

//			else

				{

				SetSignals((TUint)a1, (TUint)a2);

				}

			break;

			}

		case RBusDevComm::EControlQueryReceiveBuffer:

			r = RxCount();

			break;

		case RBusDevComm::EControlResetBuffers:

			if (AreAnyPending())

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

			else

				ResetBuffers(ETrue);

			break;

		case RBusDevComm::EControlReceiveBufferLength:

			r = RxBufferSize();

			break;

		case RBusDevComm::EControlSetReceiveBufferLength:

			if (AreAnyPending())

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

			else

				r = SetRxBufferSize((TInt)a1);

			break;

		case RBusDevComm::EControlMinTurnaroundTime:

			r = iTurnaroundMicroSeconds;			// used saved value

			break;

		case RBusDevComm::EControlSetMinTurnaroundTime:

				{

				if ((TInt)a1<0)

					a1=(TAny*)0;

				iTurnaroundMicroSeconds = (TUint)a1;			// save this

				TUint newTurnaroundMilliSeconds = (TUint)a1/1000;	// convert to ms

				if(newTurnaroundMilliSeconds != iTurnaroundMinMilliSeconds)

					{

					// POLICY: if a new turnaround time is set before the previous running timer has expired 

  					// then the timer is adjusted depending on the new value and if any

                    // write request has been queued, transmission will proceed after the timer has expired.

					if(iTurnaroundTimerStartTimeValid == 0)

						{

						iTurnaroundTimerStartTime = NKern::TickCount();

						iTurnaroundTimerStartTimeValid = 1;

						}

					if(iTurnaroundTimerStartTimeValid != 2)

						TurnaroundClear();

					if(newTurnaroundMilliSeconds > 0)

						{

						r = TurnaroundSet(newTurnaroundMilliSeconds);

						}

					}

				}

			break;

		default:

			r = KErrNotSupported;

			}

		return(r);

		}

void DChannelComm::SignalNotifyDfc(TAny* aPtr)

	{

	DChannelComm* pC = (DChannelComm*)aPtr;

	pC->DoSignalNotify();

	}

void DChannelComm::RxDataAvailableDfc(TAny* aPtr)

	{

	DChannelComm* pC = (DChannelComm*)aPtr;

	pC->DoRxDataAvailable();

	}

void DChannelComm::DoRxDataAvailable()

	{

	Complete(ERxDA, iRxDAError);

	iRxDAError = KErrNone;

	}

void DChannelComm::DoSignalNotify()

	{

	//copy the data back to the client

	if (iSignalError == KErrNone)

		iSignalError = Kern::ThreadRawWrite(iClient, iClientSignalResultPtr,&iSignalResult, sizeof(iSignalResult), iClient);

	Complete(ESigChg, iSignalError);

	iSignalError = KErrNone;

	}

void DChannelComm::CompleteTxDfc(TAny* aPtr)

	{

	DChannelComm* pC = (DChannelComm*)aPtr;

	pC->DoCompleteTx();

	}

void DChannelComm::DoCompleteTx()

	{

	Complete(ETx, iTxError);

	iTxError = KErrNone;

	}

void DChannelComm::CompleteRxDfc(TAny* aPtr)

	{

	DChannelComm* pC = (DChannelComm*)aPtr;

	pC->DoCompleteRx();

	}

void DChannelComm::DoCompleteRx()

	{

	if (iRxError == KErrNone)

		{

		//copy the data back to the client

		iRxError = Kern::ThreadDesWrite(iClient, (TDes8*)iClientDestPtr, *RxBuffer(), 0, KChunkShiftBy0, iClient);

		}

	Complete(ERx, iRxError);

	iRxError = KErrNone;

	TInt irq = NKern::DisableInterrupts(1);

	if(iTurnaroundMinMilliSeconds > 0)

		{

		// 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);

		//Record the timestamp of turnaround timer start.

		iTurnaroundTimerStartTimeValid = 1;

		iTurnaroundTimerStartTime = NKern::TickCount();

		}

	NKern::RestoreInterrupts(irq);

	}

void DChannelComm::DoCancel(TInt aMask)

	{

	if (aMask & RBusDevComm::ERequestReadCancel)

		{

		ReadCancel();

		}

	if (aMask & RBusDevComm::ERequestWriteCancel)

		{

		TInt irq = NKern::DisableInterrupts(1);

		if(iTurnaroundTransmitDelayed)

			{

			iTurnaroundTxDesPtr = 0;

			iTurnaroundTxDesLength = 0;

			iTurnaroundTransmitDelayed = EFalse;

			}

		NKern::RestoreInterrupts(irq);

		WriteCancel();

		}

	if (aMask & RBusDevComm::ERequestNotifySignalChangeCancel)

		{

		SignalChangeCancel();

		Complete(ESigChg,KErrCancel);

		}

	if (aMask & RBusDevComm::ERequestBreakCancel)

		{

		TInt irq = NKern::DisableInterrupts(1);

		if(iTurnaroundBreakDelayed)

			iTurnaroundBreakDelayed = EFalse;

		NKern::RestoreInterrupts(irq);

		iBreakDfc.Cancel();

		iBreakTimer.Cancel();

		FinishBreakImplementation(KErrCancel);

		}

	}

void DChannelComm::InitiateWrite(TAny *aTxDes, TInt aLength)

	{

//aTxDes has client side data

//aLength has the len

	if (!aTxDes)

		{

		Complete(ETx, KErrArgument);

		return;

		}

	// call the pdd to fill its buffer and write the data

	Write(iClient, aTxDes, aLength);

	}

void DChannelComm::InitiateRead(TAny *aRxDes, TInt aLength)

	{

	// Complete zero-length read immediately.  maybe not

//	if (aLength == 0)

//		{

//		Complete(ERx, KErrNone);

//		return;

//		}

	TInt max=Kern::ThreadGetDesMaxLength(iClient,aRxDes);

	if (max < Abs(aLength) || max < 0)

		Complete(ERx, KErrGeneral);

		// do not start the Turnaround timer (invalid Descriptor this read never starts)

	else

		{

		iClientDestPtr = aRxDes;

		Read(iClient, aRxDes, aLength);

		}

	}

void DChannelComm::InitiateNotifySignals(TAny *aSignalResultPtr, TInt aMask)

	{

	//aMask has the mask of signals we require

	//aSignalResultPtr is a pointer to the clients area for the result

	iClientSignalResultPtr = (TUint*)aSignalResultPtr;

	NotifySignals(iClient, aMask);

	}

void DChannelComm::NotifyReadDataAvailable()

	{

	NotifyDataAvailable();

	}

void DChannelComm::Complete(TInt aMask, TInt aReason)

	{

	if (aMask & ERx)

		Kern::RequestComplete(iClient, iRxStatus, aReason);

	if (aMask & ETx)

		Kern::RequestComplete(iClient, iTxStatus, aReason);

	if (aMask & ESigChg)

		Kern::RequestComplete(iClient, iSignalStatus, aReason);

	if (aMask & ERxDA)

		Kern::RequestComplete(iClient, iRxDAStatus, aReason);

	if (aMask & EBreak)

		Kern::RequestComplete(iClient, iBreakStatus, aReason);

	}

void DChannelComm::BreakOn()

//

// Start the driver breaking.

//

	{

	iFlags&=(~KBreakPending);

	iFlags|=KBreaking;

	PddBreak(ETrue);

	iBreakTimer.OneShot(iBreakTimeMicroSeconds, DChannelComm::FinishBreak, this);

	}

void DChannelComm::BreakOff()

//

// Stop the driver breaking.

//

	{

	PddBreak(EFalse);

	iFlags&=~KBreaking;

	}

void DChannelComm::FinishBreak(TAny* aSelf)

	{

	DChannelComm* self = (DChannelComm*)aSelf;

	self->QueueFinishBreakDfc();

	}

void DChannelComm::FinishBreakDfc(TAny* aSelf)

	{

	DChannelComm* self = (DChannelComm*)aSelf;

	self->FinishBreakImplementation(KErrNone);

	}

void DChannelComm::QueueFinishBreakDfc()

	{

	iBreakDfc.Enque();

	}

void DChannelComm::FinishBreakImplementation(TInt aBreakError)

	{

	if (iStatus==EClosed)

		{

		Complete(EBreak, KErrNotReady);

		}

	else if(LineFail())	// have signals changed in the meantime?

		{

		Complete(EBreak, KErrCommsLineFail);

		}

	else

		{

		BreakOff();

		Complete(EBreak, aBreakError);

		TInt irq = NKern::DisableInterrupts(1);

		if(iBreakDelayedTx)

			{

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

			NKern::RestoreInterrupts(irq);

			if (iStatus==EClosed)

				{

				iBreakDelayedTxDesPtr = 0;

				iBreakDelayedTxDesLength = 0;

				Complete(ETx,KErrNotReady);

				return;

				}

			// fail signals checked in the PDD

			InitiateWrite(iBreakDelayedTxDesPtr, iBreakDelayedTxDesLength);

			iBreakDelayedTxDesPtr = 0;

			iBreakDelayedTxDesLength = 0;

			}

		else 

			NKern::RestoreInterrupts(irq);

		}

	}