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

// e32\drivers\ecomm\d_comm.cpp

// 

//

#include <drivers/comm.h>

#include <kernel/kern_priv.h>

#include <e32hal.h>

#include <e32uid.h>

// Logging

#define LOG_ON(x) Kern::Printf##x

#define LOG_OFF(x)

#define LOG		LOG_OFF

//#define __UART_RX_ERROR(x)    *(TUint*)0xfeedface=(x)

//#define __OVERRUN() *(TUint*)0xfaece5=0

#define __UART_RX_ERROR(x)

#define __OVERRUN()

_LIT(KLddName,"Comm");

const TUint KXoffSignal=0x80;

//

const TUint KBreaking=0x02;

const TUint KBreakPending=0x04;

//

enum TPanic

	{

	ESetConfigWhileRequestPending,

	ESetSignalsSetAndClear,

	EResetBuffers,

	ESetReceiveBufferLength,

	};

DECLARE_STANDARD_LDD()

	{

	return new DDeviceComm;

	}

DDeviceComm::DDeviceComm()

//

// Constructor

//

	{

	LOG(("DDeviceComm::DDeviceComm"));

	iParseMask=KDeviceAllowAll;

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

	iVersion=TVersion(KCommsMajorVersionNumber,KCommsMinorVersionNumber,KCommsBuildVersionNumber);

	}

TInt DDeviceComm::Install()

//

// Install the device driver.

//

	{

	LOG(("DDeviceComm::Install"));

	return(SetName(&KLddName));

	}

void DDeviceComm::GetCaps(TDes8& aDes) const

//

// Return the Comm capabilities.

//

	{

	LOG(("DDeviceComm::GetCaps"));

	TPckgBuf<TCapsDevCommV01> b;

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

	Kern::InfoCopy(aDes,b);

	}

TInt DDeviceComm::Create(DLogicalChannelBase*& aChannel)

//

// Create a channel on the device.

//

	{

	LOG(("DDeviceComm::Create"));

	aChannel=new DChannelComm;

	return aChannel?KErrNone:KErrNoMemory;

	}

DChannelComm::DChannelComm()

//

// Constructor

//

	:	iPowerUpDfc(DChannelComm::PowerUpDfc,this,3),

		iPowerDownDfc(DChannelComm::PowerDownDfc,this,3),

		iRxDrainDfc(DChannelComm::DrainRxDfc,this,2),

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

		iTxFillDfc(DChannelComm::FillTxDfc,this,2),

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

		iTimerDfc(DChannelComm::TimerDfcFn,this,3),

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

//		iTurnaroundMinMilliSeconds(0),

//		iTurnaroundTimerRunning(EFalse),

//		iTurnaroundTransmitDelayed(EFalse),

		iTurnaroundTimer(DChannelComm::TurnaroundStartDfc, this),

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

		iTimer(DChannelComm::MsCallBack,this),

		iBreakDfc(DChannelComm::FinishBreakDfc, this, 2),

		iLock(TSpinLock::EOrderGenericIrqLow3)

	{

	LOG(("DChannelComm"));

//

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

	iRxXonChar=0xffffffff;

	iRxXoffChar=0xffffffff;

	iStatus=EOpen;

//	iFlags=0;

//	iSignals=0;

//	iFailSignals=0;

//	iHoldSignals=0;

//	iFlowControlSignals=0;

//	iAutoSignals=0;

//	iTerminatorMask[0...31]=0;

//	iShutdown=EFalse;

//	iRxCharBuf=NULL;

//	iRxErrorBuf=NULL;

//	iRxPutIndex=0;

//	iRxGetIndex=0;

//	iRxBufSize=0;

//	iFlowControlLowerThreshold=0;

//	iFlowControlUpperThreshold=0;

//	iRxDrainThreshold=0;

//	iRxBufCompleteIndex=0;

//	iInputHeld=EFalse;

//	iRxClientBufReq=NULL;

//	iRxDesPos=0;

//	iRxLength=0;

//	iRxOutstanding=EFalse;

//	iRxError=KErrNone;

//	iTxBuffer=NULL;

//	iTxPutIndex=0;

//	iTxGetIndex=0;

//	iTxBufSize=0;

//	iTxFillThreshold=0;

	iOutputHeld=0;

	iJamChar=KTxNoChar;

//	iTxDesPtr=NULL;

//	iTxDesPos=0;

//	iTxDesLength=0;

//	iTxOutstanding=EFalse;

//	iTxError=KErrNone;

//	iTimeout=10;

	iTimeout=NKern::TimerTicks(5);

	iClient=&Kern::CurrentThread();

	iClient->Open();

//	iSigNotifyMask=0;

//	iSignalsPtr=NULL;

//	iSigNotifyStatus=NULL;

	iBreakStatus=NULL;

	iNotifiedSignals=0xffffffff;

	iPinObjSetConfig=NULL;

	}

DChannelComm::~DChannelComm()

//

// Destructor

//

	{

	LOG(("~DChannelComm"));

	if (iPowerHandler)

		{

		iPowerHandler->Remove(); 

		delete iPowerHandler;

		}

    if (iRxCharBuf)

        Kern::Free(iRxCharBuf);

    if (iTxBuffer)

        Kern::Free(iTxBuffer);

	if (iBreakStatus)

		Kern::DestroyClientRequest(iBreakStatus);

	if (iSignalsReq)

		Kern::DestroyClientRequest(iSignalsReq);

	if (iPinObjSetConfig)

		Kern::DestroyVirtualPinObject(iPinObjSetConfig);

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

	}

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

	{

	LOG(("Complete(aMask=%x aReason=%d)", aMask, aReason));

	if (aMask & ERx)

		iRxBufReq.Complete(iClient, aReason);

	if (aMask & ETx)

		iTxBufReq.Complete(iClient, aReason);

	if (aMask & ESigChg)

		Kern::QueueRequestComplete(iClient, iSignalsReq, aReason);

	if ((aMask & EBreak) && iBreakStatus && iBreakStatus->IsReady())

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

	}

TInt DChannelComm::Shutdown()

	{

	__KTRACE_OPT(KPOWER,Kern::Printf("DChannelComm::Shutdown()"));

	LOG(("Shutdown()"));

    if (iStatus == EActive)

        Stop(EStopPwrDown);

    Complete(EAll, KErrAbort);

	// UART interrupts are disabled; must make sure DFCs are not queued.

	iRxDrainDfc.Cancel();

	iRxCompleteDfc.Cancel();

	iTxFillDfc.Cancel();

	iTxCompleteDfc.Cancel();

	iTimer.Cancel();

	iTurnaroundTimer.Cancel();

	iTurnaroundDfc.Cancel();

	iTimerDfc.Cancel();

	iSigNotifyDfc.Cancel();

	iPowerUpDfc.Cancel();

	iPowerDownDfc.Cancel();

	iBreakTimer.Cancel();

	iBreakDfc.Cancel();

	if (iPdd)

		SetSignals(0,iFlowControlSignals|iAutoSignals);

	return KErrCompletion;

	}

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

//

// Create the channel from the passed info.

//

	{

	LOG(("DoCreate(aUnit=%d,...)", aUnit));

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

	iPowerUpDfc.SetDfcQ(iDfcQ);

	iPowerDownDfc.SetDfcQ(iDfcQ);

	iRxDrainDfc.SetDfcQ(iDfcQ);

	iRxCompleteDfc.SetDfcQ(iDfcQ);

	iTxFillDfc.SetDfcQ(iDfcQ);

	iTxCompleteDfc.SetDfcQ(iDfcQ);

	iTimerDfc.SetDfcQ(iDfcQ);

	iSigNotifyDfc.SetDfcQ(iDfcQ);

	iTurnaroundDfc.SetDfcQ(iDfcQ);

	iBreakDfc.SetDfcQ(iDfcQ);

	iMsgQ.Receive();

	// initialise the TX buffer

	iTxBufSize=KTxBufferSize;

	iTxBuffer=(TUint8*)Kern::Alloc(iTxBufSize);

	if (!iTxBuffer)

		return KErrNoMemory;

	iTxFillThreshold=iTxBufSize>>1;

	// initialise the RX buffer

	iRxBufSize=KDefaultRxBufferSize;

	iRxCharBuf=(TUint8*)Kern::Alloc(iRxBufSize<<1);

	if (!iRxCharBuf)

		return KErrNoMemory;

	iRxErrorBuf=iRxCharBuf+iRxBufSize;

	iFlowControlLowerThreshold=iRxBufSize>>2;

	iFlowControlUpperThreshold=3*iRxBufSize>>2;

	iRxDrainThreshold=iRxBufSize>>1;

	// Create request objects

	TInt r = Kern::CreateClientDataRequest(iSignalsReq);

	if (r==KErrNone)

		r = Kern::CreateClientRequest(iBreakStatus);

	if (r==KErrNone)

		r = iRxBufReq.Create();

	if (r==KErrNone)

		r = iTxBufReq.Create();

	if (r==KErrNone)

		r = Kern::CreateVirtualPinObject(iPinObjSetConfig);

	if (r != KErrNone)

		return r;

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

	PddCheckConfig(iConfig);

	iFailSignals=FailSignals(iConfig.iHandshake);

	iHoldSignals=HoldSignals(iConfig.iHandshake);

	iFlowControlSignals=FlowControlSignals(iConfig.iHandshake);

	iAutoSignals=AutoSignals(iConfig.iHandshake);

	// create the power handler

	iPowerHandler=new DCommPowerHandler(this);

	if (!iPowerHandler)

		return KErrNoMemory;

	iPowerHandler->Add();

	DoPowerUp();

	return KErrNone;

	}

TInt DChannelComm::RequestUserHandle(DThread* aThread, TOwnerType aType)

	{

	// Ensure that each channel can only be used by a single thread.

	return (aThread!=iClient) ?  KErrAccessDenied : KErrNone;

	}

void DChannelComm::MsCallBack(TAny* aPtr)

	{

	// called from ISR when timer completes

	DChannelComm *pC=(DChannelComm*)aPtr;

	pC->iTimerDfc.Add();

	}

void DChannelComm::TimerDfcFn(TAny* aPtr)

	{

	DChannelComm *pC=(DChannelComm*)aPtr;

	pC->TimerDfc();

	}

void DChannelComm::TimerDfc()

	{

	TInt irq = __SPIN_LOCK_IRQSAVE(iLock);

	if (iRxOutstanding)

		{

		if (iRxGetIndex==iRxPutIndex)

			{

			// buffer empty after timeout period, so complete

			iRxBufCompleteIndex=iRxPutIndex;

			iRxOutstanding=EFalse;

			iRxOneOrMore=0;

			__SPIN_UNLOCK_IRQRESTORE(iLock, irq);

			DoCompleteRx();

			return;

			}

		// buffer not empty, so drain buffer and requeue timer

		__SPIN_UNLOCK_IRQRESTORE(iLock, irq);

		DoDrainRxBuffer(iRxPutIndex);

		return;

		}

	__SPIN_UNLOCK_IRQRESTORE(iLock, irq);

	}

void DChannelComm::DrainRxDfc(TAny* aPtr)

	{

	DChannelComm *pC=(DChannelComm*)aPtr;

	pC->DoDrainRxBuffer(pC->iRxPutIndex);

	}

// Drain RX buffer in a DFC

void DChannelComm::DoDrainRxBuffer(TInt aEndIndex)

	{

	// if RX completion DFC is queued, leave buffer draining to it

	if (iRxCompleteDfc.Queued())

		return;

	LOG(("DoDrainRxBuffer(aEndIndex=%d) iRxDesPos=%d iRxBufReq.iLen=%d", aEndIndex, iRxDesPos, iRxBufReq.iLen));

	// If there's an Rx request with bytes outstanding...

	if (iRxBufReq.iBuf && iRxDesPos<iRxBufReq.iLen)

        {

        TInt space=iRxBufReq.iLen-iRxDesPos; // the amount of the client buffer left to fill

        TInt avail=aEndIndex-iRxGetIndex;	 // the amount of data in the Rx buffer to copy to the client buffer

        if (avail<0) // true if the data to drain wraps around the end of the buffer (i.e. the last byte to copy has a linear address less than that of the first byte)

            avail+=iRxBufSize;

        TInt len=Min(space,avail); // total number of bytes to drain

		// Drain up to (but not beyond) the end of the Rx buffer

        TInt len1=Min(len,iRxBufSize-iRxGetIndex);  // number of bytes to the end of the buffer

        TPtrC8 des(iRxCharBuf+iRxGetIndex,len1);

		TInt r = Kern::ThreadBufWrite(iClient, iRxBufReq.iBuf, des, iRxDesPos, KChunkShiftBy0, iClient);

        if (r != KErrNone)

            {

            iRxError=r;

            DoCompleteRx();

            return;

            }

		// Update the client buffer offset and the Rx buffer read pointer with what we've done so far

        TInt irq = __SPIN_LOCK_IRQSAVE(iLock);

        iRxDesPos += len1;

        iRxGetIndex+=len1;

        if (iRxGetIndex>=iRxBufSize)

            iRxGetIndex-=iRxBufSize;

        __SPIN_UNLOCK_IRQRESTORE(iLock, irq);

		// If the data wraps around the end of the Rx buffer, now write out the second part

		// which starts at the beginning of the Rx buffer.

        len-=len1;

        if (len)

            {

            des.Set(iRxCharBuf,len);

			r=Kern::ThreadBufWrite(iClient, iRxBufReq.iBuf, des, iRxDesPos, KChunkShiftBy0, iClient);

            if (r != KErrNone)

                {

                iRxError=r;

                DoCompleteRx();

                return;

                }

			// Update client buffer offset and Rx buffer read offset

            irq = __SPIN_LOCK_IRQSAVE(iLock);

            iRxDesPos += len;

            iRxGetIndex+=len;

            __SPIN_UNLOCK_IRQRESTORE(iLock, irq);

            }

        // release flow control if necessary

        if (iInputHeld && RxCount()<=iFlowControlLowerThreshold)

            ReleaseFlowControl();

        // if we are doing ReadOneOrMore, start the timer

        if (iRxOneOrMore>0)

            {

            iTimer.OneShot(iTimeout);

            }

        }

    }

void DChannelComm::RxComplete()

{

	if (NKern::CurrentContext()==NKern::EInterrupt)

		iRxCompleteDfc.Add();

	else

		DoCompleteRx();			

}

void DChannelComm::CompleteRxDfc(TAny* aPtr)

	{

	DChannelComm *pC=(DChannelComm*)aPtr;

	pC->DoCompleteRx();

	}

void DChannelComm::DoCompleteRx()

	{

    LOG(("DoCompleteRx()"));

	if (iRxOneOrMore>0)

		iTimer.Cancel();

	if (iRxBufReq.iLen)

        {

        iRxOneOrMore=0;

        DoDrainRxBuffer(iRxBufCompleteIndex);

		iRxBufReq.Complete(iClient, iRxError);

		iRxDesPos=0;

        iRxError=KErrNone;

        // start Turnaround timer (got here because it received all data, timed out on a ReadOneOrMore or was terminated

        // early by FailSignals)

        RestartTurnaroundTimer();

        }

    else

        {

        Complete(ERx,KErrNone);

        // do not start Turnaround (got here on a request Data Available Notification)

        }

    }

void DChannelComm::TxComplete()

{

	if (NKern::CurrentContext()==NKern::EInterrupt)

		iTxCompleteDfc.Add(); 

	else

		DoCompleteTx();			

}

void DChannelComm::FillTxDfc(TAny* aPtr)

	{

	DChannelComm *pC=(DChannelComm*)aPtr;

	pC->DoFillTxBuffer();

	}

// Fill TX buffer in a DFC

void DChannelComm::DoFillTxBuffer()

	{

    LOG(("DFTB %d =%d",iTxDesPos,iTxBufReq.iLen));

	if (iTxBufReq.iBuf && iTxDesPos<iTxBufReq.iLen)

        {

        TInt space=iTxBufSize-TxCount()-1;

        TInt remaining=iTxBufReq.iLen-iTxDesPos;

        TInt len=Min(space,remaining);              // number of chars to transfer

        TInt len1=Min(len,iTxBufSize-iTxPutIndex);  // number of chars to wrap point

        TPtr8 des(iTxBuffer+iTxPutIndex,len1,len1);

        LOG(("DFTxB sp = %d rem = %d iOPH = %d",space, remaining,iOutputHeld));

		TInt r=Kern::ThreadBufRead(iClient, iTxBufReq.iBuf, des, iTxDesPos, KChunkShiftBy0);

        if (r != KErrNone)

            {

            iTxError=r;

            DoCompleteTx();

            return;

            }

        TInt irq = __SPIN_LOCK_IRQSAVE(iLock);

        iTxDesPos+=len1;

        iTxPutIndex+=len1;