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

// Implementation of STDLIB serialports.

// 

//

#include "FDESC.H"

#include <sys/types.h>

#include <string.h>		// for memcpy

#include <sys/errno.h>		// for ENOTSOCK

#include <sys/socket.h>

#include <sys/ioctl.h>

#include <sys/serial.h>

#include <c32comm.h>

//define this to allow the code to be built for ER5U without most of the notifications

//leave commented for all notifications

//#define ER5U_NOTIFICATION_SUPPORT_ONLY

#ifdef _DEBUG

_LIT(KCSerialDescPanic, "CSerialDesc");

#endif

//

//

// -----> CSerialTimer (implementation)

//

//

CSerialTimer::CSerialTimer()

	: CTimer(CActive::EPriorityHigh)

	  // Construct standard-priority active object

	{};

CSerialTimer* CSerialTimer::NewLC(CFileDescBase* aFile)

	{

	CSerialTimer* self=new (ELeave) CSerialTimer;

	CleanupStack::PushL(self);

	self->ConstructL(aFile);

	return self;

	}

CSerialTimer* CSerialTimer::NewL(CFileDescBase* aFile)

	{

	CSerialTimer* self = NewLC(aFile);

	CleanupStack::Pop();

	return self;

	}

void CSerialTimer::ConstructL(CFileDescBase* aFile)

	{

	  // Base class second-phase construction.

	CTimer::ConstructL();

	iFile = aFile;

	  // Add active object to active scheduler

	CActiveScheduler::Add(this); 

	}

CSerialTimer::~CSerialTimer()

	{

	  // Make sure we're cancelled

	Cancel();

	}

void CSerialTimer::DoCancel()

	{

	  // Base class

	CTimer::DoCancel(); 

	}

void CSerialTimer::IssueRequest()

	{

	  // There should never be an outstanding request at this point.

	__ASSERT_DEBUG(!IsActive(),User::Panic(KCSerialDescPanic,1));

	  // Request

	CTimer::After(iFile->TimeoutValue()*1000);

	}

void CSerialTimer::RunL()

	{

		//the timer has gone off.

	iFile->ReadCancel();

	iFile->TimedMessage = NULL;

	iFile->ReadIsTimed = EFalse;

	iFile->ReadWasCancelled = ETrue;

	delete this;

	}

/****/

NONSHARABLE_CLASS(CNotifier) : public CActive

	{

	public:

		CNotifier();

		~CNotifier();

		void IssueRequest(TInt aRequest, TInt* aRequestParams=NULL);

		static CNotifier* NewLC(CSerialDesc* aPort);

		static CNotifier* NewL(CSerialDesc* aPort);

		void Construct(CSerialDesc* aPort);

		void Complete(TInt aVal);

	private:

		enum RequestTypes {None, DataAvailable, OutputEmpty, Break, Signals, WriteErrors};

		void DoCancel();

		void RunL();

		CSerialDesc * iSerialPort;

		enum RequestTypes iRequest;

		TUint iRequestData;

		TInt* iRequestParams;

} ;

CNotifier::CNotifier() : CActive(CActive::EPriorityStandard), iRequest(None), iRequestData(0), iRequestParams(NULL)

	{

	}

void CNotifier::IssueRequest(TInt aRequest, TInt* aRequestParams)

	{

	iRequestParams = aRequestParams;

#ifndef ER5U_NOTIFICATION_SUPPORT_ONLY

	if (KNotifyDataAvailable == aRequest)

		{

		iRequest = DataAvailable;

		iSerialPort->NotifyDataAvailable(iStatus);

		}

	else if (KNotifyOutputEmpty == aRequest)

		{

		iRequest = OutputEmpty;

		iSerialPort->NotifyOutputEmpty(iStatus);

		}

	else if (KNotifyBreakInt == aRequest)

		{

		iRequest = Break;

		iSerialPort->NotifyBreak(iStatus);

		}

	else if (aRequest & (KNotifyCD|KNotifyCTS|KNotifyDSR|KNotifyRI))	//signals

		{

		TUint signalsRequested = 0;

		//build up the mask of signals to request

		if (aRequest & KNotifyCD) signalsRequested |=  KSignalDCD;

		if (aRequest & KNotifyCTS) signalsRequested |=  KSignalCTS;

		if (aRequest & KNotifyDSR) signalsRequested |=  KSignalDSR;

		if (aRequest & KNotifyRI) signalsRequested |=  KSignalRNG;

		iRequest = Signals;

		iSerialPort->NotifySignalChange(iStatus, iRequestData, signalsRequested);

		}

	else 

#endif	//ER5U_NOTIFICATION_SUPPORT_ONLY

		if (aRequest & (KNotifyFramingError|KNotifyOverrunError|KNotifyParityError))

		{

		iRequest = WriteErrors;

		iSerialPort->NotifyWriteErrors(iStatus, &iRequestData, aRequest);

		}

	SetActive();

	}

void CNotifier::RunL()

	{

	//now what!

	//cancel all the others

	//use iRequest to determine what we are doing here

	CNotifier** ppn = NULL;

	switch (iRequest)

		{

#ifndef ER5U_NOTIFICATION_SUPPORT_ONLY

		case DataAvailable:

			iSerialPort->iNotifyParamPtr[0] = KNotifyDataAvailable;

			ppn = &iSerialPort->iDataAvailableNotifier;

			break;

		case OutputEmpty:

			iSerialPort->iNotifyParamPtr[0] = KNotifyOutputEmpty;

			ppn = &iSerialPort->iOutputEmptyNotifier;

			break;

		case Break:

			iSerialPort->iNotifyParamPtr[0] = KNotifyBreakInt;

			ppn = &iSerialPort->iBreakNotifier;

			break;

		case Signals:

			{

			ppn = &iSerialPort->iSignalsNotifier;

			iSerialPort->iNotifyParamPtr[0] = 0;

			iSerialPort->iNotifyParamPtr[1] = 0;

			if (iRequestData & KDCDChanged)

				{

				iSerialPort->iNotifyParamPtr[0] |=  KNotifyCD;

				iSerialPort->iNotifyParamPtr[1] |=  (iRequestData & KSignalDCD);

				}

			if (iRequestData & KCTSChanged)

				{

				iSerialPort->iNotifyParamPtr[0] |=  KNotifyCTS;

				iSerialPort->iNotifyParamPtr[1] |=  (iRequestData & KSignalCTS);

				}

			if (iRequestData & KDSRChanged)

				{

				iSerialPort->iNotifyParamPtr[0] |=  KNotifyDSR;

				iSerialPort->iNotifyParamPtr[1] |=  (iRequestData & KSignalDSR);

				}

			if (iRequestData & KRNGChanged)

				{

				iSerialPort->iNotifyParamPtr[0] |=  KNotifyRI;

				iSerialPort->iNotifyParamPtr[1] |=  (iRequestData & KSignalRNG);

				}

			}

			break;

#endif //ER5U_NOTIFICATION_SUPPORT_ONLY

		case WriteErrors:

			{

			iSerialPort->iNotifyParamPtr[0] = iRequestData;

			iSerialPort->iNotifyParamPtr[1] = 0;

			ppn = &iSerialPort->iErrorsNotifier;

			}

			break;

		default:

			__ASSERT_DEBUG(EFalse, User::Panic(KCSerialDescPanic, 1));

			break;

		}

	//cancel all the others

	iSerialPort->CancelNotifiers(this);	//telling it who we are.

	//and complete the outstanding user request

	User::RequestComplete(iSerialPort->iNotifyStatus, iStatus.Int());

	delete this;

	if (ppn) *ppn = NULL;

	}

void CNotifier::DoCancel()

	{

	switch (iRequest)

		{

#ifndef ER5U_NOTIFICATION_SUPPORT_ONLY

		case DataAvailable:

			iSerialPort->NotifyDataAvailableCancel();

			break;

		case OutputEmpty:

			iSerialPort->NotifyOutputEmptyCancel();

			break;

		case Break:

			iSerialPort->NotifyBreakCancel();

			break;

		case Signals:

			iSerialPort->NotifySignalChangeCancel();

			break;

#endif //ER5U_NOTIFICATION_SUPPORT_ONLY

		case WriteErrors:

			iSerialPort->NotifyWriteErrorsCancel();

			break;

		default:

			break;

		}

	}

void CNotifier::Complete(TInt aVal)

	{

	TRequestStatus* ps = &iStatus;

	User::RequestComplete(ps, aVal);

	}

CNotifier* CNotifier::NewLC(CSerialDesc* aPort)

	{

	CNotifier* self=new (ELeave) CNotifier;

	CleanupStack::PushL(self);

	self->Construct(aPort);

	return self;

	}

CNotifier* CNotifier::NewL(CSerialDesc* aPort)

	{

	CNotifier* self = NewLC(aPort);

	CleanupStack::Pop();

	return self;

	}

void CNotifier::Construct(CSerialDesc* aPort)

	{

	iSerialPort = aPort;

	CActiveScheduler::Add(this) ;  // add to active scheduler

	}

CNotifier::~CNotifier()

	{

	Cancel();

	}

/****/

// The Serial descriptor class

TInt CSerialDesc::Open(RCommServ& aSession, const wchar_t* name, int mode, int /*perms*/)

	{

	//the name will be a wide version of COM?: or IRCOM?: where ? is a number 1 to 9.

	//this has already been checked in the call to CFileDescBase open.

	TInt err = KErrArgument;

	if (L'C' == name[0])

		{

		//serial port

		//load the comms module we require

		err = aSession.LoadCommModule(_L("ECUART"));

		if (KErrAlreadyExists != err && KErrNone != err)	//problem

			return err;

		//convert the name into an epoc port name

		//eg COMM::0

		TBuf<7> epocName(_L("COMM::0"));

		epocName[6] = (TText)(name[3] - 1);

		//try opening as a dte or a dce

		err = iCommPort.Open(aSession, epocName, (enum TCommAccess)mode, ECommRoleDTE);

		if (err) 			

			err = iCommPort.Open(aSession, epocName, (enum TCommAccess)mode, ECommRoleDCE);

		}

	else

		{

		//IR port

		err = aSession.LoadCommModule(_L("IrCOMM"));

		if (KErrAlreadyExists != err && KErrNone != err)	//problem

			return err;

		//convert the name into an epoc port name

		//eg COMM::0

		TBuf<9> epocName(_L("IrCOMM::0"));

		epocName[8] = (TText)(name[5] - 1);

		//try opening as a dte or a dce

		err = iCommPort.Open(aSession, epocName, (enum TCommAccess)mode, ECommRoleDTE);

		if (err) 			

			err = iCommPort.Open(aSession, epocName, (enum TCommAccess)mode, ECommRoleDCE);

		}

	return err;

	}

void CSerialDesc::UserClose()

	{

	IoctlCancel();

	}

TInt CSerialDesc::FinalClose()

	{

	iCommPort.Close();

	return 0;

	}

TBool CSerialDesc::TimedRead()

	{

		//if we have a timeout without a threshold we need an external timer

		return (-1 != iReadTimeout && -1 == iReadThreshold);

	}

void CSerialDesc::Read(TDes8& aBuf, TRequestStatus& aStatus)

	{

	//do a read..

	//4 different ones

	if (-1 == iReadThreshold)

		{

		iCommPort.ReadOneOrMore(aStatus, aBuf);

		}

	else

		{

		TInt len = (iReadThreshold < aBuf.MaxLength() ? iReadThreshold : aBuf.MaxLength());

		if (-1 == iReadTimeout)

			{

			//read threshold with no timeout

			iCommPort.Read(aStatus, aBuf, len);

			}

		else

			{

			//read threshold and timeout

			TTimeIntervalMicroSeconds32 timeout(iReadTimeout*1000);

			iCommPort.Read(aStatus, timeout, aBuf, len);

			}

		}

	}

void CSerialDesc::Write (TDes8& aBuf, TRequestStatus& aStatus)

	{

	iCommPort.Write(aStatus, aBuf);

	}

void CSerialDesc::Ioctl(int aCmd, void* aParam, TRequestStatus& aStatus)

	{

	TInt ret=KErrNone;

	if (aParam)

		{

		aCmd &= ~0x4000;	//mask off the queue bit!

		switch (aCmd)

			{

			case COMMIOCTL_SETSIGNALS:

				{

				int* param =REINTERPRET_CAST(int*,aParam);

				TUint setMask = (TUint)param[0];

				TUint clearMask = (TUint)param[1];

				iCommPort.SetSignals(setMask, clearMask);

				}

				break;

			case COMMIOCTL_GETSIGNALS:

				{

				int* param =REINTERPRET_CAST(int*,aParam);

				TUint signals = iCommPort.Signals();

				*param = (int)signals;

				}

				break;

			case COMMIOCTL_SETCONFIG:	

				{

				SerialConfig * param =REINTERPRET_CAST(SerialConfig *,aParam);

				TCommConfig cfg;

				TCommConfigV01& cfg01 =cfg();

				cfg01.iRate = (enum TBps)param->iRate; 

				cfg01.iDataBits = (enum TDataBits)param->iDataBits;

				cfg01.iStopBits = (enum TStopBits)param->iStopBits; 

				cfg01.iParity = (enum TParity)param->iParity; 

				cfg01.iHandshake = param->iHandshake;

				cfg01.iParityError = param->iParityError;

				cfg01.iFifo = param->iFifo;

				cfg01.iSpecialRate = param->iSpecialRate;

				cfg01.iTerminatorCount = param->iTerminatorCount;

				cfg01.iXonChar = param->iXonChar; 

				cfg01.iXoffChar = param->iXoffChar; 

				cfg01.iParityErrorChar = param->iParityErrorChar; 

				cfg01.iSIREnable = (enum TSir)param->iSIREnable; 

				cfg01.iSIRSettings = param->iSIRSettings;

				for (int i =0; i < ConfigMaxTerminators; i++)

					cfg01.iTerminator[i] = param->iTerminator[i];

				iCommPort.SetConfig(cfg);

				}

				break;

			case COMMIOCTL_GETCONFIG:	

				{

				SerialConfig * param =REINTERPRET_CAST(SerialConfig *,aParam);

				TCommConfig cfg;

				iCommPort.Config(cfg);

				TCommConfigV01& cfg01 =cfg();

				param->iRate = (enum Bps)cfg01.iRate;

				param->iDataBits = (enum DataBits)cfg01.iDataBits;

				param->iStopBits = (enum StopBits)cfg01.iStopBits;

				param->iParity = (enum Parity)cfg01.iParity;

				param->iHandshake = cfg01.iHandshake;

				param->iParityError = cfg01.iParityError;

				param->iFifo = cfg01.iFifo;

				param->iSpecialRate = cfg01.iSpecialRate;

				param->iTerminatorCount = cfg01.iTerminatorCount;

				for (int i =0; i < ConfigMaxTerminators; i++)

					param->iTerminator[i] = cfg01.iTerminator[i];

				param->iXonChar = cfg01.iXonChar;

				param->iXoffChar = cfg01.iXoffChar;

				param->iParityErrorChar = cfg01.iParityErrorChar;

				param->iSIREnable = (enum Sir)cfg01.iSIREnable;

				param->iSIRSettings = cfg01.iSIRSettings;

				}

				break;

			case COMMIOCTL_BREAK:	

				{

				int* param =REINTERPRET_CAST(int*,aParam);

				TTimeIntervalMicroSeconds32 time(*param);

				iCommPort.Break(aStatus, time);

				return;

				}

			case COMMIOCTL_SETREADTIMEOUT:

				{

				int* param =REINTERPRET_CAST(int*,aParam);

				iReadTimeout = *param;

				}

				break;

			case COMMIOCTL_GETREADTIMEOUT:

				{