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

				{

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

				*param = iReadTimeout;

				}

				break;

			case COMMIOCTL_SETREADTHRESHOLD:

				{

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

				iReadThreshold = *param;

				}

				break;

			case COMMIOCTL_GETREADTHRESHOLD:

				{

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

				*param = iReadThreshold;

				}

				break;

			case COMMIOCTL_SETBUFFERLENGTH:

				{

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

				iCommPort.SetReceiveBufferLength(TInt(*param));

				}

				break;

			case COMMIOCTL_GETBUFFERLENGTH:

				{

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

				*param = iCommPort.ReceiveBufferLength();

				}

				break;

			case COMMIOCTL_NOTIFYSUPPORTED:

				{

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

				*param = NotifiesSupported();

				}

				break;

			case REAL_COMMIOCTL_NOTIFY:

				{

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

				//if they are supported

				if (RequestedNotifiesSupported(*param))

					{

					//see if we need real notifications or we are to fake them

					//always use aStatus for the final thing

					TBool wantDataAvailable = *param & KNotifyDataAvailable;

					TBool wantOutputEmpty = *param & KNotifyOutputEmpty;

					TBool wantBreakInt = *param & KNotifyBreakInt;

					TBool wantSignals = *param & (KNotifyCD|KNotifyCTS|KNotifyDSR|KNotifyRI);

					TBool wantErrors = *param & (KNotifyFramingError|KNotifyOverrunError|KNotifyParityError);

					iDataAvailableNotifier = NULL;

					iOutputEmptyNotifier = NULL;

					iBreakNotifier = NULL;

					iSignalsNotifier = NULL;

					iErrorsNotifier = NULL;

					TRAPD(tRes,

						{

						if (wantDataAvailable) iDataAvailableNotifier = CNotifier::NewL(this);

						if (wantOutputEmpty) iOutputEmptyNotifier = CNotifier::NewL(this);

						if (wantBreakInt) iBreakNotifier = CNotifier::NewL(this);

						if (wantSignals) iSignalsNotifier = CNotifier::NewL(this);

						if (wantErrors) iErrorsNotifier = CNotifier::NewL(this);

						});

					if (KErrNone == tRes)

						{

						//smashing, no failure, request those events

						if (wantDataAvailable) iDataAvailableNotifier->IssueRequest(KNotifyDataAvailable);

						if (wantOutputEmpty) iOutputEmptyNotifier->IssueRequest(KNotifyOutputEmpty);

						if (wantBreakInt) iBreakNotifier->IssueRequest(KNotifyBreakInt);

						if (wantSignals) iSignalsNotifier->IssueRequest(*param & (KNotifyCD|KNotifyCTS|KNotifyDSR|KNotifyRI));

						if (wantErrors) iErrorsNotifier->IssueRequest(*param & (KNotifyFramingError|KNotifyOverrunError|KNotifyParityError));

						iRequestedSignals = *param;

						iNotifyParamPtr = REINTERPRET_CAST(unsigned int*,aParam);

						iNotifyStatus = &aStatus;

						aStatus = KRequestPending;

						return;			//on an async call here

						}

					else

						{

						//deal with the problem

						//we're going to have to tidy up, delete things etc

						delete iDataAvailableNotifier;

						delete iOutputEmptyNotifier;

						delete iBreakNotifier;

						delete iSignalsNotifier;

						delete iErrorsNotifier;

						iDataAvailableNotifier = NULL;

						iOutputEmptyNotifier = NULL;

						iBreakNotifier = NULL;

						iSignalsNotifier = NULL;

						iErrorsNotifier = NULL;

						ret = tRes;

						}

					}

				else

					{

					ret = KErrNotSupported;

					*param &=~NotifiesSupported();

					}

				}

				break;

			default:

				ret=KErrNotSupported;

				break;

			}

		}

		else

			ret = KErrArgument;

	Complete(aStatus,ret);

	}

TInt CSerialDesc::IoctlCompletion(int /*aCmd*/, void* /*aParam*/, TInt aStatus)

	{

	return aStatus;

	}

void CSerialDesc::ReadCancel()

	{

	iCommPort.ReadCancel();

	}

void CSerialDesc::IoctlCancel()

	{

	//stop the ioctl if in progress

	CancelNotifiers(NULL);

	if (iNotifyStatus)

		{

		iNotifyParamPtr[0] = 0;

		Complete(*iNotifyStatus, -3);

		}

	}

TInt CSerialDesc::ReadCompletion (TDes8& /*aBuf*/, TInt aStatus)

	{

	//The read has completed.  

	//See if we need to signal 'cos it completed with an error and someone is waiting 

	//on a notification.  In which case we need to complete the request with the correct results.

	if ((aStatus < 0) && (iRequestedSignals&(KNotifyFramingError|KNotifyOverrunError|KNotifyParityError)))	//we have a signal outstanding we can deal with here

		{

		switch (aStatus)

			{

			case KErrCommsFrame:	//comms framing error

				if (iRequestedSignals&KNotifyFramingError)

					Notify(KNotifyFramingError);

				break;

			case KErrCommsOverrun:	//comms overrrun error

 				if (iRequestedSignals&KNotifyOverrunError)

					Notify(KNotifyOverrunError);

				break;

			case KErrCommsParity:	//comms parity error

 				if (iRequestedSignals&KNotifyParityError)

					Notify(KNotifyParityError);

				break;

			default:

				//an error we don't signal

				break;

			}

		}

	return aStatus;

	}

TBool CSerialDesc::RequestedNotifiesSupported(TInt aRequested)

	{

	//return true if these notifies are OK.  0 if any of them are illegal

	TInt mask = ~(NotifiesSupported());

	return !(aRequested&mask);

	}

TInt CSerialDesc::NotifiesSupported()

	{

	//return which notifies are supported.

	//looks like the driver/server is going to have to be interrogated here

	//start with the ones we can fake

	TInt supported = KNotifyFramingError|KNotifyOverrunError|KNotifyParityError;

#ifndef ER5U_NOTIFICATION_SUPPORT_ONLY

	//get the supported ones from C32

	TCommCaps2 devCap;

	TCommCapsV02& deviceCapabilities = devCap();

	deviceCapabilities.iNotificationCaps = 0;

	iCommPort.Caps(devCap);

	//signals

	if (deviceCapabilities.iNotificationCaps & KNotifySignalsChangeSupported)

		supported |= (KNotifyCD|KNotifyCTS|KNotifyDSR|KNotifyRI);

	//break interrupt

	if (deviceCapabilities.iNotificationCaps & KNotifyBreakSupported)

		supported |= KNotifyBreakInt;

	//Data Available

	if (deviceCapabilities.iNotificationCaps & KNotifyDataAvailableSupported)

		supported |= KNotifyDataAvailable;

	//Output Empty

	if (deviceCapabilities.iNotificationCaps & KNotifyOutputEmptySupported)

		supported |= KNotifyOutputEmpty;

#endif  //ER5U_NOTIFICATION_SUPPORT_ONLY

	return supported;

	}

void CSerialDesc::Notify(TInt aVal)

	{

	if (iErrorsNotifier)

		{

//		iNotifyParamPtr[0] = aVal;

		*iRequestDataPtr = aVal;

		iErrorsNotifier->Complete(0);

		}

	}

#ifndef ER5U_NOTIFICATION_SUPPORT_ONLY

void CSerialDesc::NotifyDataAvailable(TRequestStatus& aStatus)

	{

	iCommPort.NotifyDataAvailable(aStatus);

	}

void CSerialDesc::NotifyDataAvailableCancel()

	{

	iCommPort.NotifyDataAvailableCancel();

	}

void CSerialDesc::NotifyOutputEmpty(TRequestStatus& aStatus)

	{

	iCommPort.NotifyOutputEmpty(aStatus);

	}

void CSerialDesc::NotifyOutputEmptyCancel()

	{

	iCommPort.NotifyOutputEmptyCancel();

	}

void CSerialDesc::NotifyBreak(TRequestStatus& aStatus)

	{

	iCommPort.NotifyBreak(aStatus);

	}

void CSerialDesc::NotifyBreakCancel()

	{

	iCommPort.NotifyBreakCancel();

	}

void CSerialDesc::NotifySignalChange(TRequestStatus& aStatus, TUint& aRequestData, TUint aSignalsMask)

	{

	iCommPort.NotifySignalChange(aStatus, aRequestData, aSignalsMask);

	}

void CSerialDesc::NotifySignalChangeCancel()

	{

	iCommPort.NotifySignalChangeCancel();

	}

#endif  //ER5U_NOTIFICATION_SUPPORT_ONLY

void CSerialDesc::NotifyWriteErrors(TRequestStatus& aStatus, TUint* aRequestData, TUint aSignalsMask)

	{

	iRequestedSignals = aSignalsMask;

	iRequestDataPtr = aRequestData;

//	iNotifyParamPtr = aRequestData;

	aStatus = KRequestPending;

	}

void CSerialDesc::NotifyWriteErrorsCancel()

	{

	iErrorsNotifier->Complete(KErrCancel);

	}

TUint CSerialDesc::Signals()

	{

	return iCommPort.Signals();

	}

void CSerialDesc::CancelNotifiers(const CNotifier* aCompletedNotifier)

	{

#ifndef ER5U_NOTIFICATION_SUPPORT_ONLY

	if (iDataAvailableNotifier && (aCompletedNotifier != iDataAvailableNotifier))

		{

		iDataAvailableNotifier->Cancel();

		delete iDataAvailableNotifier;

		iDataAvailableNotifier = NULL;

		}

	if (iOutputEmptyNotifier && (aCompletedNotifier != iOutputEmptyNotifier))

		{

		iOutputEmptyNotifier->Cancel();

		delete iOutputEmptyNotifier;

		iOutputEmptyNotifier = NULL;

		}

	if (iBreakNotifier && (aCompletedNotifier != iBreakNotifier))

		{

		iBreakNotifier->Cancel();

		delete iBreakNotifier;

		iBreakNotifier = NULL;

		}

	if (iSignalsNotifier && (aCompletedNotifier != iSignalsNotifier))

		{

		iSignalsNotifier->Cancel();

		delete iSignalsNotifier;

		iSignalsNotifier = NULL;

		}

#endif //ER5U_NOTIFICATION_SUPPORT_ONLY

	if (iErrorsNotifier && (aCompletedNotifier != iErrorsNotifier))

		{

		iErrorsNotifier->Cancel();

		delete iErrorsNotifier;

		iErrorsNotifier = NULL;

		}

	}