/*

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

*

*/

#include <acminterface.h>

#include "AcmPort.h"

#include "AcmPortFactory.h"

#include "AcmUtils.h"

#include "AcmWriter.h"

#include "AcmReader.h"

#include "AcmPanic.h"

#endif

const TUint KCapsRate=(   KCapsBps50

						| KCapsBps75

						| KCapsBps110

						| KCapsBps134

						| KCapsBps150

						| KCapsBps300

						| KCapsBps600

						| KCapsBps1200

						| KCapsBps1800

						| KCapsBps2000

						| KCapsBps2400

						| KCapsBps3600

						| KCapsBps4800

						| KCapsBps7200

						| KCapsBps9600

						| KCapsBps19200

						| KCapsBps38400

						| KCapsBps57600

						| KCapsBps115200

						| KCapsBps230400

						| KCapsBps460800

						| KCapsBps576000

						| KCapsBps115200

						| KCapsBps4000000 );

const TUint KCapsDataBits=KCapsData8;		

const TUint KCapsStopBits=KCapsStop1;		

const TUint KCapsParity=KCapsParityNone;	

const TUint KCapsHandshaking=(

						  KCapsSignalCTSSupported

						| KCapsSignalDSRSupported

						| KCapsSignalRTSSupported

						| KCapsSignalDTRSupported); 

const TUint KCapsSignals=(

							KCapsSignalCTSSupported

						|	KCapsSignalDSRSupported

						|	KCapsSignalRTSSupported

						|	KCapsSignalDTRSupported);

const TUint KCapsFifo = 0;

const TUint KCapsSIR = 0; ///< Serial Infrared capabilities

const TUint KCapsNotification = KNotifySignalsChangeSupported;			

const TUint KCapsRoles = 0; 				

const TUint KCapsFlowControl = 0;							

const TBps		KDefaultDataRate = EBps115200;		

const TDataBits KDefaultDataBits = EData8;			

const TParity	KDefaultParity	 = EParityNone; 	

const TStopBits KDefaultStopBits = EStop1;			

const TUint 	KDefaultHandshake = 0;	

///< Default XON character is <ctrl>Q				

const TText8	KDefaultXon 	 = 17; 

///< Default XOFF character is <ctrl>S

const TText8	KDefaultXoff	 = 19; 

// Starting size of each of the receive and transmit buffers.

const TUint KDefaultBufferSize = 0x1000;

CAcmPort* CAcmPort::NewL(const TUint aUnit, MAcmPortObserver& aFactory)

/**

 * Make a new CPort for the comm server

 *

 * @param aFactory The observer of the port, to be notified when the port 

 * closes.

 * @param aUnit The port number.

 * @return Ownership of a newly created CAcmPort object

 */

	{

	CAcmPort* self = new(ELeave) CAcmPort(aUnit, aFactory);

	CleanupClosePushL(*self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

void CAcmPort::ConstructL()

/**

 * Standard second phase constructor. Create owned classes and initialise the 

 * port.

 */

	{

	iReader = CAcmReader::NewL(*this, KDefaultBufferSize);

	iWriter = CAcmWriter::NewL(*this, KDefaultBufferSize);

	TName name;

	name.Num(iUnit);

	iCommServerConfig.iBufFlags = 0;

	iCommServerConfig.iBufSize = iReader->BufSize();

	iCommConfig.iRate			= KDefaultDataRate;

	iCommConfig.iDataBits		= KDefaultDataBits;

	iCommConfig.iParity 		= KDefaultParity;

	iCommConfig.iStopBits		= KDefaultStopBits;

	iCommConfig.iHandshake		= KDefaultHandshake;

	iCommConfig.iParityError	= 0;

	iCommConfig.iFifo			= 0;

	iCommConfig.iSpecialRate	= 0;

	iCommConfig.iTerminatorCount= 0;

	iCommConfig.iXonChar		= KDefaultXon;

	iCommConfig.iXoffChar		= KDefaultXoff;

	iCommConfig.iParityErrorChar= 0;

	iCommConfig.iSIREnable		= ESIRDisable;

	iCommConfig.iSIRSettings	= 0;

	}

CAcmPort::CAcmPort(const TUint aUnit, MAcmPortObserver& aObserver) 

 :	iCommNotification(iCommNotificationDes()),

	iObserver(aObserver),

	iUnit(aUnit)

/**

 * Constructor.

 *

 * @param aObserver The observer of the port, to be notified when the port 

 * closes.

 * @param aUnit The port number.

 */

	{

	}

void CAcmPort::StartRead(const TAny* aClientBuffer, TInt aLength)

/**

 * Downcall from C32. Queue a read.

 *

 * @param aClientBuffer pointer to the client's buffer

 * @param aLength number of bytes to read

 */

	{

	if ( !iAcm )

		{

		ReadCompleted(KErrAccessDenied);

		return;

		}

	// Analyse the request and call the relevant API on the data reader. NB We 

	// do not pass requests for zero bytes to the data reader. They are an 

	// RComm oddity we should handle here.

	if(iReader->IsNotifyDataAvailableQueryPending())

		{

		ReadCompleted(KErrInUse);

		return;

		}

	if ( aLength < 0 )

		{

		iReader->ReadOneOrMore(aClientBuffer, static_cast<TUint>(-aLength));

		}

	else if ( aLength > 0 )

		{

		iReader->Read(aClientBuffer, static_cast<TUint>(aLength));

		}

	else

		{

		// Obscure RComm API feature- complete zero-length Read immediately, 

		// to indicate that the hardware is powered up.

		ReadCompleted(KErrNone);

		}

	}

void CAcmPort::ReadCancel()

/**

 * Downcall from C32. Cancel a read.

 */

	{

	if ( !iAcm )

		{

		return;

		}

	iReader->ReadCancel();

	}

TInt CAcmPort::QueryReceiveBuffer(TInt& aLength) const

/**

 * Downcall from C32. Get the amount of data in the receive buffer.

 *

 * @param aLength reference to where the amount will be written to

 * @return Error.

 */

	{

	if ( !iAcm )

		{

		return KErrAccessDenied;

		}

	aLength = static_cast<TInt>(iReader->BufLen());

	return KErrNone;

	}

void CAcmPort::ResetBuffers(TUint aFlags)

/**

 * Downcall from C32. Reset zero or more of the Tx and Rx buffers.

 *

 * @param aFlags Flags indicating which buffer(s) to reset.

 */

	{

	if ( aFlags & KCommResetRx )

		{

		iReader->ResetBuffer();

		}

	if ( aFlags & KCommResetTx )

		{

		iWriter->ResetBuffer();

		}

	}

void CAcmPort::StartWrite(const TAny* aClientBuffer, TInt aLength)

/**

 * Downcall from C32. Queue a write

 *

 * @param aClientBuffer pointer to the Client's buffer

 * @param aLength number of bytes to write

 */

	{

	if ( !iAcm )

		{

		WriteCompleted(KErrAccessDenied);

		return;

		}

	if ( aLength < 0 )

		{

		// Negative length makes no sense.

		WriteCompleted(KErrArgument);

		return;

		}

	// NB We pass zero-byte writes down to the LDD as normal. This results in 

	// a zero-length packet being sent to the host.

	iWriter->Write(aClientBuffer, static_cast<TUint>(aLength));

	}

void CAcmPort::WriteCancel()

/**

 * Downcall from C32. Cancel a pending write

 */

	{

	if ( !iAcm )

		{

		return;

		}

	iWriter->WriteCancel();

	}

void CAcmPort::Break(TInt aTime)

/**

 * Downcall from C32. Send a break signal to the host.

 * Note that it is assumed that the NotifyBreak() request only applies to 

 * break signals sent from the host.

 *

 * @param aTime Length of break in microseconds

 */

	{

	if ( !iAcm )

		{

		return;

		}

	iBreak = ETrue;

	iCancellingBreak = EFalse;

	// Use the time value directly as microseconds are given. We are a USB 

	// 'device' so the RComm client is always on the device side.

	TInt err = iAcm->BreakRequest(CBreakController::EDevice,

		CBreakController::ETiming,

		TTimeIntervalMicroSeconds32(aTime));

	// Note that the break controller may refuse our request if a host-driven 

	// break is outstanding.

	if ( err )

		{

		iBreak = EFalse;

		BreakCompleted(err);

		}						

	}

void CAcmPort::BreakCancel()

/**

 * Downcall from C32. Cancel a pending break.

 */

	{

	if ( !iAcm )

		{

		return;

		}

	iCancellingBreak = ETrue;

	TInt err = iAcm->BreakRequest(CBreakController::EDevice,

		CBreakController::EInactive);

	// Note that the device cannot turn off a break if there's a host-driven 

	// break in progress.

	if ( err )

		{

		iCancellingBreak = EFalse;

		}

	// Whether BreakOff worked or not, reset our flag saying we're no longer 

	// interested in any subsequent completion anyway.

	iBreak = EFalse;

	}

TInt CAcmPort::GetConfig(TDes8& aDes) const

/**

 * Downcall from C32. Pass a config request. Only supports V01.

 *

 * @param aDes config will be written to this descriptor 

 * @return Error.

 */

	{

	if ( !iAcm )

		{

		return KErrAccessDenied;

		}

	if ( aDes.Length() < static_cast<TInt>(sizeof(TCommConfigV01)) )

		{

		return KErrNotSupported;

		}

	TCommConfig commConfigPckg;

	TCommConfigV01& commConfig = commConfigPckg();

	commConfig = iCommConfig;

	aDes.Copy(commConfigPckg);

	return KErrNone;

	}

TInt CAcmPort::SetConfig(const TDesC8& aDes)

/**

 * Downcall from C32. Set config on the port using a TCommConfigV01 package.

 *

 * @param aDes descriptor containing the new config

 * @return Error

 */

	{

	if ( !iAcm )

		{

		return KErrAccessDenied;

		}

	if ( aDes.Length() < static_cast<TInt>(sizeof(TCommConfigV01)) )

		{

		return KErrNotSupported;

		}

	TCommConfig configPckg;

	configPckg.Copy(aDes);

	TCommConfigV01& config = configPckg();

	// Tell the reader object about the new terminators. Pass the whole config 

	// struct by reference for ease.

	iReader->SetTerminators(config);

	HandleConfigNotification(config.iRate,

		config.iDataBits,

		config.iParity,

		config.iStopBits,

		config.iHandshake);

	iCommConfig = config;

	return KErrNone;

	}

void CAcmPort::HandleConfigNotification(TBps aRate,

										TDataBits aDataBits,

										TParity aParity,

										TStopBits aStopBits,

										TUint aHandshake)

/**

 * Construct and complete the config notification data structure.

 * @param aRate 		New data rate

 * @param aDataBits 	New number of data bits

 * @param aParity		New parity check setting

 * @param aStopBits 	New stop bit setting

 * @param aHandshake	New handshake setting

 */

	{