/*

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

*

*/

#include <acminterface.h>

#include "AcmPort.h"

#include "AcmPortFactory.h"

#include "AcmUtils.h"

#include "AcmWriter.h"

#include "AcmReader.h"

#include "AcmPanic.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "AcmPortTraces.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

 */

	{

	OstTraceFunctionEntry0( CACMPORT_NEWL_ENTRY );

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

	CleanupClosePushL(*self);

	self->ConstructL();

	CleanupStack::Pop();

	OstTraceFunctionExit0( CACMPORT_NEWL_EXIT );

	return self;

	}

void CAcmPort::ConstructL()

/**

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

 * port.

 */

	{

	OstTraceFunctionEntry0( CACMPORT_CONSTRUCTL_ENTRY );

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

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

	TName name;

	TInt	err;

	name.Num(iUnit);

	err = SetName(&name);

	if (err < 0)

		{

		OstTrace1( TRACE_FATAL, CACMPORT_CONSTRUCTL, "CAcmPort::ConstructL;err=%d", err );

		User::Leave(err);

		}

	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;

	OstTraceFunctionExit0( CACMPORT_CONSTRUCTL_EXIT );

	}

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.

 */

	{

	OstTraceFunctionEntry0( CACMPORT_CACMPORT_CONS_ENTRY );

	OstTraceFunctionExit0( CACMPORT_CACMPORT_DES_EXIT );

	}

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

 */

	{

	OstTraceFunctionEntry0( CACMPORT_STARTREAD_ENTRY );

	OstTraceExt2( TRACE_NORMAL, CACMPORT_STARTREAD, "CAcmPort::StartRead;aClientBuffer=%p;aLength=%d", aClientBuffer, aLength );

	if ( !iAcm )

		{

		OstTrace0( TRACE_NORMAL, CACMPORT_STARTREAD_DUP1, "CAcmPort::StartRead;\t***access denied" );

		ReadCompleted(KErrAccessDenied);

		OstTraceFunctionExit0( CACMPORT_STARTREAD_EXIT );

		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)

		{

		OstTraceExt1( TRACE_FATAL, CACMPORT_STARTREAD_DUP3, "CAcmPort::StartRead;iReader=%p", iReader );

		__ASSERT_DEBUG( EFalse, User::Panic(KAcmPanicCat, EPanicInternalError) );

		}

	if(iReader->IsNotifyDataAvailableQueryPending())

		{

		ReadCompleted(KErrInUse);

		OstTraceFunctionExit0( CACMPORT_STARTREAD_EXIT_DUP1 );

		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.

		OstTrace0( TRACE_NORMAL, CACMPORT_STARTREAD_DUP2, "CAcmPort::StartRead;\tcompleting immediately with KErrNone" );

		ReadCompleted(KErrNone);

		}

	OstTraceFunctionExit0( CACMPORT_STARTREAD_EXIT_DUP2 );

	}

void CAcmPort::ReadCancel()

/**

 * Downcall from C32. Cancel a read.

 */

	{

	OstTraceFunctionEntry0( CACMPORT_READCANCEL_ENTRY );

	if ( !iAcm )

		{

		OstTrace0( TRACE_NORMAL, CACMPORT_READCANCEL, "CAcmPort::ReadCancel;\t***access denied" );

		OstTraceFunctionExit0( CACMPORT_READCANCEL_EXIT );

		return;

		}

	if (!iReader)

		{

		OstTraceExt1( TRACE_FATAL, CACMPORT_READCANCEL_DUP1, "CAcmPort::ReadCancel;iReader=%p", iReader );

		__ASSERT_DEBUG( EFalse, User::Panic(KAcmPanicCat, EPanicInternalError) );

		}

	iReader->ReadCancel();

	OstTraceFunctionExit0( CACMPORT_READCANCEL_EXIT_DUP1 );

	}

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.

 */

	{

	OstTraceFunctionEntry0( CACMPORT_QUERYRECEIVEBUFFER_ENTRY );

	if ( !iAcm )

		{

		OstTrace0( TRACE_NORMAL, CACMPORT_QUERYRECEIVEBUFFER, "CAcmPort::QueryReceiveBuffer;\t***access denied" );

		OstTraceFunctionExit0( CACMPORT_QUERYRECEIVEBUFFER_EXIT );

		return KErrAccessDenied;

		}

	if (!iReader)

		{

		OstTraceExt1( TRACE_FATAL, CACMPORT_QUERYRECEIVEBUFFER_DUP2, "CAcmPort::QueryReceiveBuffer;iReader=%p", iReader );

		__ASSERT_DEBUG( EFalse, User::Panic(KAcmPanicCat, EPanicInternalError) );

		}

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

	OstTrace1( TRACE_NORMAL, CACMPORT_QUERYRECEIVEBUFFER_DUP1, "CAcmPort::QueryReceiveBuffer;aLength=%d", aLength );

	OstTraceFunctionExit0( CACMPORT_QUERYRECEIVEBUFFER_EXIT_DUP1 );

	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.

 */

	{

	OstTraceFunctionEntry0( CACMPORT_RESETBUFFERS_ENTRY );

	OstTrace1( TRACE_NORMAL, CACMPORT_RESETBUFFERS, "CAcmPort::ResetBuffers;aFlags=%d", aFlags );

	if ( aFlags & KCommResetRx )

		{

		OstTrace0( TRACE_NORMAL, CACMPORT_RESETBUFFERS_DUP1, "CAcmPort::ResetBuffers;\tresetting Rx buffer" );

		if (!iReader)

			{

			OstTraceExt1( TRACE_FATAL, CACMPORT_RESETBUFFERS_DUP3, "CAcmPort::ResetBuffers;iReader=%p", iReader );

			__ASSERT_DEBUG( EFalse, User::Panic(KAcmPanicCat, EPanicInternalError) );

			}

		iReader->ResetBuffer();

		}

	if ( aFlags & KCommResetTx )

		{

		OstTrace0( TRACE_NORMAL, CACMPORT_RESETBUFFERS_DUP2, "CAcmPort::ResetBuffers;\tresetting Tx buffer" );

		if (!iWriter)

			{

			OstTraceExt1( TRACE_FATAL, CACMPORT_RESETBUFFERS_DUP4, "CAcmPort::ResetBuffers;iWriter=%p", iWriter );

			__ASSERT_DEBUG( EFalse, User::Panic(KAcmPanicCat, EPanicInternalError) );

			}

		iWriter->ResetBuffer();

		}

	OstTraceFunctionExit0( CACMPORT_RESETBUFFERS_EXIT );

	}

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

 */

	{

	OstTraceFunctionEntry0( CACMPORT_STARTWRITE_ENTRY );

	OstTraceExt2( TRACE_NORMAL, CACMPORT_STARTWRITE, "CAcmPort::StartWrite;aClientBuffer=%p;aLength=%d", aClientBuffer, aLength );

	if ( !iAcm )

		{

		OstTrace0( TRACE_NORMAL, CACMPORT_STARTWRITE_DUP1, "CAcmPort::StartWrite;\t***access denied" );

		WriteCompleted(KErrAccessDenied);

		OstTraceFunctionExit0( CACMPORT_STARTWRITE_EXIT );

		return;

		}

	if ( aLength < 0 )

		{

		// Negative length makes no sense.

		OstTrace0( TRACE_NORMAL, CACMPORT_STARTWRITE_DUP2, "CAcmPort::StartWrite;\taLength is negative-completing immediately with KErrArgument" );

		WriteCompleted(KErrArgument);

		OstTraceFunctionExit0( CACMPORT_STARTWRITE_EXIT_DUP1 );

		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.

	if (!iWriter)

		{

		OstTraceExt1( TRACE_FATAL, CACMPORT_STARTWRITE_DUP3, "CAcmPort::StartWrite;iWriter=%p", iWriter );

		__ASSERT_DEBUG( EFalse, User::Panic(KAcmPanicCat, EPanicInternalError) );

		}

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

	OstTraceFunctionExit0( CACMPORT_STARTWRITE_EXIT_DUP2 );

	}

void CAcmPort::WriteCancel()

/**

 * Downcall from C32. Cancel a pending write

 */

	{

	OstTraceFunctionEntry0( CACMPORT_WRITECANCEL_ENTRY );

	if ( !iAcm )

		{

		OstTrace0( TRACE_NORMAL, CACMPORT_WRITECANCEL, "CAcmPort::WriteCancel;\t***access denied" );

		OstTraceFunctionExit0( CACMPORT_WRITECANCEL_EXIT );

		return;

		}

	if (!iWriter)

		{

		OstTraceExt1( TRACE_FATAL,CACMPORT_WRITECANCEL_DUP1, "CAcmPort::WriteCancel;iWriter=%p", iWriter );

		__ASSERT_DEBUG( EFalse, User::Panic(KAcmPanicCat, EPanicInternalError) );

		}

	iWriter->WriteCancel();

	OstTraceFunctionExit0( CACMPORT_WRITECANCEL_EXIT_DUP1 );

	}

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

 */

	{

	OstTraceFunctionEntry0( CACMPORT_BREAK_ENTRY );

	OstTrace1( TRACE_NORMAL, CACMPORT_BREAK, "CAcmPort::Break;\taTime=%d (microseconds)", aTime );

	if ( !iAcm )

		{

		OstTrace0( TRACE_NORMAL, CACMPORT_BREAK_DUP1, "CAcmPort::Break;\t***access denied" );

		OstTraceFunctionExit0( CACMPORT_BREAK_EXIT );

		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));

	OstTrace1( TRACE_NORMAL, CACMPORT_BREAK_DUP2, "CAcmPort::Break;\tBreakRequest = %d", err );

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

	// break is outstanding.

	if ( err )

		{

		OstTrace1( TRACE_NORMAL, CACMPORT_BREAK_DUP3, "CAcmPort::Break;\tcalling BreakCompleted with %d", err );

		iBreak = EFalse;

		BreakCompleted(err);

		}						

	OstTraceFunctionExit0( CACMPORT_BREAK_EXIT_DUP1 );

	}

void CAcmPort::BreakCancel()

/**

 * Downcall from C32. Cancel a pending break.

 */

	{

	OstTraceFunctionEntry0( CACMPORT_BREAKCANCEL_ENTRY );

	if ( !iAcm )

		{

		OstTrace0( TRACE_NORMAL, CACMPORT_BREAKCANCEL, "CAcmPort::BreakCancel;\t***access denied" );

		OstTraceFunctionExit0( CACMPORT_BREAKCANCEL_EXIT );

		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.

	OstTrace1( TRACE_NORMAL, CACMPORT_BREAKCANCEL_DUP1, "CAcmPort::BreakCancel;\tBreakRequest = %d", err );

	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;

	OstTraceFunctionExit0( CACMPORT_BREAKCANCEL_EXIT_DUP1 );

	}

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.

 */

	{

	OstTraceFunctionEntry0( CACMPORT_GETCONFIG_ENTRY );

	if ( !iAcm )

		{

		OstTrace0( TRACE_NORMAL, CACMPORT_GETCONFIG, "CAcmPort::GetConfig;\t***access denied" );

		OstTraceFunctionExit0( CACMPORT_GETCONFIG_EXIT );

		return KErrAccessDenied;

		}

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

		{

		OstTrace0( TRACE_NORMAL, CACMPORT_GETCONFIG_DUP12, "CAcmPort::GetConfig;\t***not supported" );

		OstTraceFunctionExit0( CACMPORT_GETCONFIG_EXIT_DUP1 );

		return KErrNotSupported;

		}

	TCommConfig commConfigPckg;

	TCommConfigV01& commConfig = commConfigPckg();

	commConfig = iCommConfig;

	aDes.Copy(commConfigPckg);

	OstTrace1( TRACE_NORMAL, CACMPORT_GETCONFIG_DUP1, "CAcmPort::GetConfig;\tiCommConfig.iRate=%d", iCommConfig.iRate );

	OstTrace1( TRACE_NORMAL, CACMPORT_GETCONFIG_DUP2, "CAcmPort::GetConfig;\tiCommConfig.iDataBits = %d", iCommConfig.iDataBits );

	OstTrace1( TRACE_NORMAL, CACMPORT_GETCONFIG_DUP3, "CAcmPort::GetConfig;\tiCommConfig.iStopBits = %d", iCommConfig.iStopBits );

	OstTrace1( TRACE_NORMAL, CACMPORT_GETCONFIG_DUP4, "CAcmPort::GetConfig;\tiCommConfig.iParity = %d", iCommConfig.iParity );

	OstTrace1( TRACE_NORMAL, CACMPORT_GETCONFIG_DUP5, "CAcmPort::GetConfig;\tiCommConfig.iHandshake = %d", iCommConfig.iHandshake );

	OstTrace1( TRACE_NORMAL, CACMPORT_GETCONFIG_DUP6, "CAcmPort::GetConfig;\tiCommConfig.iParityError = %d", iCommConfig.iParityError );

	OstTrace1( TRACE_NORMAL, CACMPORT_GETCONFIG_DUP7, "CAcmPort::GetConfig;\tiCommConfig.iFifo = %d", iCommConfig.iFifo );

	OstTrace1( TRACE_NORMAL, CACMPORT_GETCONFIG_DUP8, "CAcmPort::GetConfig;\tiCommConfig.iSpecialRate = %d", iCommConfig.iSpecialRate );

	OstTrace1( TRACE_NORMAL, CACMPORT_GETCONFIG_DUP9, "CAcmPort::GetConfig;\tiCommConfig.iTerminatorCount = %d", iCommConfig.iTerminatorCount );

	OstTrace1( TRACE_NORMAL, CACMPORT_GETCONFIG_DUP10, "CAcmPort::GetConfig;\tiCommConfig.iSIREnable = %d", iCommConfig.iSIREnable );

	OstTrace1( TRACE_NORMAL, CACMPORT_GETCONFIG_DUP11, "CAcmPort::GetConfig;\tiCommConfig.iSIRSettings = %d", iCommConfig.iSIRSettings );

	OstTraceFunctionExit0( CACMPORT_GETCONFIG_EXIT_DUP2 );

	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

 */

	{

	OstTraceFunctionEntry0( CACMPORT_SETCONFIG_ENTRY );

	if ( !iAcm )

		{

		OstTrace0( TRACE_NORMAL, CACMPORT_SETCONFIG, "CAcmPort::SetConfig;\t***access denied" );

		OstTraceFunctionExit0( CACMPORT_SETCONFIG_EXIT );

		return KErrAccessDenied;

		}

	OstTraceExt3( TRACE_NORMAL, CACMPORT_SETCONFIG_DUP1, "CAcmPort::SetConfig;\tlength of argument=%d;TCommConfigV01=%d;TCommConfigV02=%d", aDes.Length(), (TInt)sizeof(TCommConfigV01), (TInt)sizeof(TCommConfigV02) );

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

		{

		OstTrace0( TRACE_NORMAL, CACMPORT_SETCONFIG_DUP2, "CAcmPort::SetConfig;\t***not supported" );

		OstTraceFunctionExit0( CACMPORT_SETCONFIG_EXIT_DUP1 );

		return KErrNotSupported;

		}

	TCommConfig configPckg;

	configPckg.Copy(aDes);

	TCommConfigV01& config = configPckg();

	OstTrace1( TRACE_DUMP, CACMPORT_SETCONFIG_DUP3, "CAcmPort::SetConfig;\tconfig.iRate=%d", config.iRate );

	OstTrace1( TRACE_DUMP, CACMPORT_SETCONFIG_DUP4, "CAcmPort::SetConfig;\tconfig.iDataBits=%d", config.iDataBits );

	OstTrace1( TRACE_DUMP, CACMPORT_SETCONFIG_DUP5, "CAcmPort::SetConfig;\tconfig.iStopBits=%d", config.iStopBits );

	OstTrace1( TRACE_DUMP, CACMPORT_SETCONFIG_DUP6, "CAcmPort::SetConfig;\tconfig.iParity=%d", config.iParity );

	OstTrace1( TRACE_DUMP, CACMPORT_SETCONFIG_DUP7, "CAcmPort::SetConfig;\tconfig.iHandshake=%d", config.iHandshake );

	OstTrace1( TRACE_DUMP, CACMPORT_SETCONFIG_DUP8, "CAcmPort::SetConfig;\tconfig.iParityError=%d", config.iParityError );

	OstTrace1( TRACE_DUMP, CACMPORT_SETCONFIG_DUP9, "CAcmPort::SetConfig;\tconfig.iFifo=%d", config.iFifo );

	OstTrace1( TRACE_DUMP, CACMPORT_SETCONFIG_DUP10, "CAcmPort::SetConfig;\tconfig.iSpecialRate=%d", config.iSpecialRate );