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