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

// C32 Baseband Channel Adaptor(BCA) APIs implementation.

// This file contains all the API implementation of the C32BCA interface for Symbian OS.

// 

//

/**

 @file

 @internalComponent

*/

#include "C32Bca.h"

#include <cdbcols.h>

#include <commsdat_partner.h>

using namespace BasebandChannelAdaptation;

using namespace BasebandChannelAdaptation::C32Bca;

const static TUint KVersion = ((static_cast<TUint>(KC32BcaMajorVersionNumber)) << 16) | KC32BcaMinorVersionNumber;

/**

C++ constructor for an object representing a c32 async user

@param aUser the target of the notifications originating in C32

@param aPort the C32 port to be used with this object

@param aAoPriority the priority to assign to this active object

*/

CCommBase::CCommBase(MC32User& aUser, RComm& aPort, TInt aAoPriority):

	CActive(aAoPriority),

	iUser(aUser),

	iPort(aPort)

	{

	CActiveScheduler::Add(this);

	}

/**

C++ destructor */		

CCommBase::~CCommBase()

	{

	}

/**

C++ constructor 

The comm-reader has a higher priority than the comm-writer, to

ensure the reader gets the chance to receive the incomming data

@param aUser the target of the notifications originating in C32

@param aPort the C32 port to be used with this object

*/

CCommReader::CCommReader(MC32User& aUser, RComm& aPort):

	CCommBase(aUser, aPort, EPriorityHigh)

	{

	}

/** 

C++ destructor */

CCommReader::~CCommReader()

	{

	Cancel();

	}

/**

Cancels the outstanding read */

void CCommReader::DoCancel()

	{

	iPort.ReadCancel();

	}

/**

Issues a read on the serial port 

@param aBuf the buffer to read to */		

void CCommReader::Read(TDes8& aBuf)

	{

	iPort.ReadOneOrMore(iStatus, aBuf);	

	SetActive();

	}

/**

Called on read completion */	

void CCommReader::RunL()

	{

	iUser.CommReadComplete(iStatus.Int());

	}

/**

C++ constructor

The comm-writer has a lower priority than the comm-reader, to

ensure the reader gets the chance to receive the incomming data

@param aUser the target of the notifications originating in C32

@param aPort the C32 port to be used with this object */	

CCommWriter::CCommWriter(MC32User& aUser, RComm& aPort):

	CCommBase(aUser, aPort, EPriorityUserInput)

	{

	}

/** 

C++ destructor */

CCommWriter::~CCommWriter()

	{

	Cancel();

	}

/**

Issues a write on the serial port */

void CCommWriter::Write(const TDesC8& aBuf)

	{

	iPort.Write(iStatus, aBuf);

	SetActive();

	}

/**

Called when the write completes

*/

void CCommWriter::RunL()

	{

	iUser.CommWriteComplete(iStatus.Int());

	}

/**

Cancels the outstanding write

*/

void CCommWriter::DoCancel()

	{

	iPort.WriteCancel();

	}

/**

C++ constructor

@param aUser the target of the notifications originating in C32

@param aPort the C32 port to be used with this object

Note on Monitor AO priority:

Monitor AO is the same priority as the Reader / Writer by design. 

We do NOT want link failure notification to complete before all possible outstanding reads / writes

have completed, to make sure that we do not lose any data that was already received from the

baseband and is buffered by the driver or the CSY.

Consider a scenario where a UDP datagram is received by the CSY, and then the serial link is

severed (e.g. cable is unplugged by the user). If the Monitor has higher priority than reader/writer,

we may get failure notification before we are notified on the read of this UDP datagram, potentially

resulting in its loss (E.g. PPP shuts down when on Link Down notification.)

*/	

CCommLinkMonitor::CCommLinkMonitor(MC32User& aUser, RComm& aPort):

	CCommBase(aUser, aPort, EPriorityStandard) 

	{

	}

/**

Sets the object to monitor the link for the configured Role, DTE or DCE

@param aMask DTE or DCE: determines when the link is considered to be down.

*/

void CCommLinkMonitor::Setup(TUint32 aMask)

	{

	iNotifyChangeSignalMask = aMask;	

	}

/**

Requests to be notified when the link is down.

Can be called an more than once

*/

void CCommLinkMonitor::NotifyLinkDown()

	{

	ASSERT(!IsActive());

	// get the current state of the line so when we get notification we can tell if it really has changed	

	iSavedSignalState = iPort.Signals(iNotifyChangeSignalMask) & iNotifyChangeSignalMask;

	iPort.NotifySignalChange(iStatus, iSignals, iNotifyChangeSignalMask);

	SetActive();

	}

/**	

Called when EIA-232 signals change,i.e. on potential link failure

*/

void CCommLinkMonitor::RunL()

	{

	// We report link failure if and only if a monitored line went from high to low.

	// Method: mask the saved signals using inverted monitored bits in the signal bitmask,

	// to filter out all transitions except for high -> low. 

	// 1 & ~0 = 1;    1 & ~1 = 0; 0 & ~1 = 0; 0 & ~0 = 0

	// This is necessary, because we may be monitoring more than one signal, and the change can be arbitrary.

	if ((~(iNotifyChangeSignalMask & iSignals)) & iSavedSignalState) 

		{		

		iUser.CommLinkDown(KErrCommsLineFail);

		}

	iSavedSignalState = iSignals & iNotifyChangeSignalMask;	// update saved state with relevant bits	

	iPort.NotifySignalChange(iStatus, iSignals, iNotifyChangeSignalMask);

	SetActive(); 

	// Note: If the link went down, the user will likely shutdown the BCA on outstanding signal notification. 

	}

/**

Cancels notification request of link failure */	

void CCommLinkMonitor::DoCancel()

	{

	iPort.NotifySignalChangeCancel();

	}

/**

* default constructor to create a C32Bca instance.

*/

CC32Bca::CC32Bca()	

	{

	}

/**

2nd phase of construction: allocates member objects 

@leave when members cannot be constructed. */

void CC32Bca::ConstructL()

	{

	__ASSERT_DEBUG(!iReader, Panic(EReaderAlreadyExists));

	__ASSERT_DEBUG(!iWriter, Panic(EWriterAlreadyExists));

	__ASSERT_DEBUG(!iLinkMonitor, Panic(EMonitorAlreadyExists));

	// Comm is not initialized yet. We have to be Opened before it can be used. C32 panics otherwise.

	iReader = new (ELeave)CCommReader(*this, iComm);

	iWriter = new (ELeave)CCommWriter(*this, iComm);

	// Monitor is created upon user request only, we may never need it at all.

	}

/**

* Destructor 

*/	

CC32Bca::~CC32Bca()

	{

	CloseCommDbConnection(); 

	CloseCommPort(); 	// Cancels reader / writer / monitor

	// N.B.: 

	// It is critical that these objects are cancelled before deletion. Else DoCancel operates on closed C32 port, 

	// causing C32 to panic. 

	delete iReader;

	delete iWriter;

	delete iLinkMonitor; // Note: may have never been created.

	}

/** This method deletes the BCA itself.*/

void CC32Bca::Release()

	{

	delete this;

	}

/**

* Informs that the BCA is required by the client(for instance, Raw IP NIF).Comms Server is

* connected, and serial port is opened.

* @param aStatus complete status, KErrNone if successful, C32 error code otherwise.

* @param aChannelId comm port name.

*/	

void CC32Bca::Open(TRequestStatus& aStatus, const TDesC& aChannelId)

	{

	// We don't have the ConstructL, so we have to allocate memory here.

	aStatus = KRequestPending;

	// avoid compiler warning.

	TRequestStatus* ptrStatus = &aStatus;

	if(iCommPortOpen)

		{

		User::RequestComplete(ptrStatus,KErrNone);

		return;	

		}

	if(aChannelId == KChannelIdNotOverridden) // Channel ID is not supplied - Comm Port Name is not overriden.

		{									 // Read it from CommDB.

		// Fetch port name from CommDB.

		TRAPD(commPortErr, ReadCommPortFromCommDbL(iCommPort));

		// If the column is missing from CommDB, we can get an empty string with KErrNone.

		// Opening RComm with empty string as Port name fails with ECUART, LOOOPBACK CSYs. 

		// with different error codes on 8.1 and 9.0. 

		// It would be better to intercept such invalid value and fail here.

		// This is not done, because theoretically it is possible to write a CSY that somehow takes an 

		// emty descriptor as a port name. As of December 2004, C32 does not allow that, however, this

		// may change in the future.

		// So, we just log a warning.

		if(KErrNone == commPortErr && iCommPort.Size() == 0)

			{

			}		

		if(KErrNone != commPortErr) // Fatal: we do not have a port name. Can't open RComm.

			{

			CloseCommDbConnection();

			User::RequestComplete(ptrStatus, commPortErr);

			return;

			}		

		}

	else // Channel ID supplied - use it as Port Name.

		{

		_LIT(KDoubleColon, "::");

		TInt len1 = aChannelId.Find(KDoubleColon);

		if (len1 < KErrNone)

			{

			User::RequestComplete(ptrStatus, KErrBadName);

			return;	

			}

		else

			{

			TUint numPos = len1 + KDoubleColon.iTypeLength;

			TInt len2 = (aChannelId.Mid(numPos)).Find(KDoubleColon);

			if (len2 < KErrNone)

				{

				iCommPort = aChannelId;

				}

			else

				{

				iCommPort = aChannelId.Mid(numPos);

				iCsyName = aChannelId.Mid(0, len1);

				iCsyNameOverride = ETrue;

				}

			}

		}

	// We have the Port Name at this point: either supplied as a parameter, or read from CommDB.

	if(!iCsyNameOverride) // CSY name is not provisioned by Ioctl: read it from CommDB.

		{

		TRAPD(getCsyErr, ReadCsyNameFromCommDbL(iCsyName));

		if(KErrNone != getCsyErr) // Fatal: we do not have a CSY name. Can't load CSY module.

			{

			// We do not use a hardcoded value (e.g. ECUART), because the client code or the environment are

			// confused - it is better to fail them, rather than mask their problems.

			CloseCommDbConnection();

			User::RequestComplete(ptrStatus,getCsyErr);

			return;

			}

		}

	// We have the CSY name at this point, either provisioned via Ioctl, or read from CommDB.

	// Decide the Comm Role (DCE / DTE) of the port.

	TBool isCommRoleDefault = EFalse;

	// We use a concept of "Default Comm Role", because C32 has it. We could use DTE as a default

	// setting, but we prefer to call the "default" method on C32 and let it decide what the role should be.

	if(!iCommRoleOverride) // Port role not overriden via Ioctl

		{

		TRAPD(getCommRoleErr, ReadCommRoleFromCommDbL(iCommRole));

		if(KErrNone != getCommRoleErr) // Port role not specified via CommDb

			{

			isCommRoleDefault = ETrue; // Port role not specified via Ioctl or CommDb

			}

		}

	// We have the Comm Role: provisioned via Ioctl, read from CommDB, or default(DTE)

	CloseCommDbConnection(); // We do not read any settings once the connection is opened. 	

	// We have all the necessary C32 settings at this point.

	// Open the actual C32 session:

	TInt ret = iCommServ.Connect();

	if(ret)

		{

		User::RequestComplete(ptrStatus,ret);

		return;

		}

	ret = iCommServ.LoadCommModule(iCsyName);

	if(ret)

		{

		User::RequestComplete(ptrStatus,ret);

		return;

		}

	if(isCommRoleDefault)

		{

		ret = iComm.Open(iCommServ, iCommPort, ECommShared);

		}

	else

		{

		ret = iComm.Open(iCommServ, iCommPort, ECommShared, iCommRole);	

		}

	if(ret)

		{

		User::RequestComplete(ptrStatus,ret);

		return;

		}

	//

	//Open successfull, we update our state.

	//

	// We may have been closed, and are being reopened now. Make sure no errors persist from the previous session.

	iErrorOnNextRead  = KErrNone; 

	iErrorOnNextWrite = KErrNone;

	iCommPortOpen = ETrue;

	User::RequestComplete(ptrStatus,KErrNone);

	// Don't start control line monitoring. This is done on user request via Ioctl only.

	}

/**

 Shuts the BCA channel down in a graceful manner. BCA releases its resources.

 Cancels all outstanding operations: Writes, Reads and Ioctls.

 Due to the specifics of C32Bca implementation, this call completes immediately and is identical to ::Close.

 @param aStatus completion status: Always KErrNone.

*/	

void CC32Bca::Shutdown(TRequestStatus& aStatus)

	{

	aStatus = KRequestPending;

	CloseCommPort();

	// Don't notify reader / writer / monitor. Read / Write should not be called after this anyway. Let C32 panic.

	TRequestStatus* request = &aStatus;

	User::RequestComplete(request, KErrNone);

	}

/**

* Closes the BCA immediately. BCA releases its resources.

* cancels all Writes, Reads and Controls.

*/	

void CC32Bca::Close()

	{

	CloseCommPort();

	}

/**

* Queues a Read on C32 serial port.

* @param aStatus complete status, KErrNone if successful, C32 error code otherwise.

* @param aBuf buffer for data to be read.

* @note The buffer is owned by the client. Client must not access / modify the buffer until the Read completes.

*/	

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

	{

	iReadRequest = &aStatus;

	*iReadRequest = KRequestPending;

	if(iErrorOnNextRead)

		{

		User::RequestComplete(iReadRequest, iErrorOnNextRead);

		// Error persists until the BCA is closed and opened

		}

	else

		{

		iReader->Read(aBuf);	

		}

	}

/**

* Queues a Write on C32 serial port.

* @param aStatus the complete status, KErrNone if successful, C32 error code otherwise.

* @param aBuf the buffer to sent.

* @note The buffer is owned by the client. Client must not access / modify the buffer until the Write completes.

*/	

void CC32Bca::Write(TRequestStatus& aStatus,const TDesC8& aBuf)

	{

	iWriteRequest = &aStatus;

	*iWriteRequest = KRequestPending;

	if(iErrorOnNextWrite)

		{

		User::RequestComplete(iWriteRequest, iErrorOnNextWrite);

		// Error persists until BCA is closed and opened.

		}

	else

		{

		iWriter->Write(aBuf);	

		}

	}

/**