/*

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

*

*/

#include <e32std.h>

#include "CdcDataInterface.h"

#include "ActiveReader.h"

#include "ActiveWriter.h"

#include "AcmPanic.h"

#include "AcmUtils.h"

#include "ActiveReadOneOrMoreReader.h"

#include "ActiveDataAvailableNotifier.h"

#include "inifile.h"

#include <usb/usblogger.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, "ECACM");

#endif

#ifdef __HEADLESS_ACM_TEST_CODE__

#pragma message ("Building headless ACM (performance test code for RDevUsbcClient)")

#endif // __HEADLESS_ACM_TEST_CODE__

CCdcDataInterface::CCdcDataInterface(const TDesC16& aIfcName)

/**

 * Overloaded Constructor using interface name.

 * @param aIfcName contains the interface name

 */

 :	CCdcInterfaceBase(aIfcName),

 	iPacketSize(KDefaultMaxPacketTypeBulk)

	{

	}

CCdcDataInterface* CCdcDataInterface::NewL(const TDesC16& aIfcName)

/**

 * Create a new CCdcDataInterface object and construct it using interface name

 * This call will return an object with a valid USB configuration

 *

 * @param aParent Observer.

 * @param aIfcName Contains the interface name

 * @return A pointer to the new object

 */

	{

	LOG_STATIC_FUNC_ENTRY

	LOGTEXT2(_L("\tData Ifc Name = %S"), &aIfcName);

	CCdcDataInterface* self = new (ELeave) CCdcDataInterface(aIfcName);

	CleanupStack::PushL(self);

	self->ConstructL();

	CLEANUPSTACK_POP(self);

	return self;

	}

void CCdcDataInterface::ConstructL()

/**

 * Construct the object

 * This call registers the object with the USB device driver

 *

 * @param aParent Observer.

 */

	{

	BaseConstructL();

	iReadOneOrMoreReader  = CActiveReadOneOrMoreReader::NewL(*this, iLdd, EEndpoint2);

	iReader = CActiveReader::NewL(*this, iLdd, EEndpoint2);

	iDataAvailableNotifier = CActiveDataAvailableNotifier::NewL(*this, iLdd, EEndpoint2);

	iWriter = CActiveWriter::NewL(*this, iLdd, EEndpoint1);

	iLinkState = CLinkStateNotifier::NewL(*this, iLdd);

	iLinkState->Start();

	LOGTEXT(_L8("\tchecking ecacm.ini"));

	iHostCanHandleZLPs = EFalse;

	GetHostZLPHandlingFromFile();

	LOGTEXT(_L8("\tfinished checking ecacm.ini"));

	}

TInt CCdcDataInterface::SetUpInterface()

/**

 * Retrieves the device capabilities and searches for suitable input and 

 * output bulk endpoints. If suitable endpoints are found, an interface 

 * descriptor for the endpoints is registered with the LDD.

 */

	{

	LOGTEXT(_L8(">>CCdcDataInterface::SetUpInterface"));

	TUsbDeviceCaps dCaps;

	TInt ret = iLdd.DeviceCaps(dCaps);

	LOGTEXT(_L8("\tchecking result of DeviceCaps"));

	if ( ret )

		{

		LOGTEXT2(_L8("<<CCdcDataInterface::SetUpInterface ret=%d"), ret);

		return ret;

		}

	TInt maxBulkPacketSize = (dCaps().iHighSpeed) ? KMaxPacketTypeBulkHS : KMaxPacketTypeBulkFS;

	const TUint KRequiredNumberOfEndpoints = 2;

	const TUint totalEndpoints = static_cast<TUint>(dCaps().iTotalEndpoints);

	LOGTEXT2(_L8("\tiTotalEndpoints = %d"), totalEndpoints);

	if ( totalEndpoints < KRequiredNumberOfEndpoints )

		{

		LOGTEXT2(_L8("<<CCdcDataInterface::SetUpInterface ret=%d"), 

			KErrGeneral);

		return KErrGeneral;

		}

	// Endpoints

	TUsbcEndpointData data[KUsbcMaxEndpoints];

	TPtr8 dataptr(reinterpret_cast<TUint8*>(data), sizeof(data), sizeof(data));

	ret = iLdd.EndpointCaps(dataptr);

	LOGTEXT(_L8("\tchecking result of EndpointCaps"));

	if ( ret )

		{

		LOGTEXT2(_L8("<<CCdcDataInterface::SetUpInterface ret=%d"), ret);

		return ret;

		}

	// 

	TUsbcInterfaceInfoBuf ifc;

	TBool foundIn = EFalse;

	TBool foundOut = EFalse;

	for ( TUint i = 0; !(foundIn && foundOut) && i < totalEndpoints; i++ )

		{

		const TUsbcEndpointCaps* caps = &data[i].iCaps;

		__ASSERT_DEBUG(caps, 

			_USB_PANIC(KAcmPanicCat, EPanicInternalError));

		if (data[i].iInUse)

			continue;

		//get the max packet size it can potentially support

		//it's possible that it can support Isoch (1023) which is greater

		//than max for Bulk at 64

		const TInt maxSize = Min (	maxBulkPacketSize, 

									caps->MaxPacketSize() );

		const TUint KBulkInFlags = KUsbEpTypeBulk | KUsbEpDirIn;

		const TUint KBulkOutFlags = KUsbEpTypeBulk | KUsbEpDirOut;

		// use EEndPoint1 for TX (IN) EEndpoint1

		if (! foundIn && (caps->iTypesAndDir & KBulkInFlags) == KBulkInFlags)

			{

			ifc().iEndpointData[0].iType  = KUsbEpTypeBulk;

			ifc().iEndpointData[0].iDir   = KUsbEpDirIn; 

			//get the max packet size it can potentially support

			//it's possible that it can support Isoch (1023) which is greater

			//than max for Bulk at 64

			ifc().iEndpointData[0].iSize  = maxSize;

			foundIn = ETrue;

			}

		// use EEndPoint2 for RX (OUT) endpoint

		else if (	!foundOut 

			&&		(caps->iTypesAndDir & KBulkOutFlags) == KBulkOutFlags

			)

			{

			// EEndpoint2 is going to be our RX (OUT, read) endpoint

			ifc().iEndpointData[1].iType  = KUsbEpTypeBulk;

			ifc().iEndpointData[1].iDir   = KUsbEpDirOut;

			//get the max packet size it can potentially support

			//it's possible that it can support Isoch (1023) which is greater

			//than max for Bulk at 64

			ifc().iEndpointData[1].iSize  = maxSize;

			foundOut = ETrue;

			}

		}

	if (! (foundIn && foundOut))

		{

		LOGTEXT2(_L8("<<CCdcDataInterface::SetUpInterface ret=%d"), 

			KErrGeneral);

		return KErrGeneral;

		}

		// If the device supports USB High-speed, then we request 64KB buffers

		// (otherwise the default 4KB ones will do).

	TUint bandwidthPriority = (EUsbcBandwidthOUTDefault | EUsbcBandwidthINDefault);

	if (dCaps().iHighSpeed)

		{

		bandwidthPriority = (EUsbcBandwidthOUTPlus2 | EUsbcBandwidthINPlus2);

		}

	ifc().iString = &iIfcName;

	ifc().iTotalEndpointsUsed = KRequiredNumberOfEndpoints;

	ifc().iClass.iClassNum	  = 0x0A; // Table 18- Data Interface Class

	ifc().iClass.iSubClassNum = 0x00; // Section 4.6- unused.

	ifc().iClass.iProtocolNum = 0x00; // Table 19- no class specific protocol required

	// Indicate that this interface does not expect any control transfers 

	// from EP0.

	ifc().iFeatureWord |= KUsbcInterfaceInfo_NoEp0RequestsPlease;

	LOGTEXT(_L8("\tcalling SetInterface"));

	// Zero effectively indicates that alternate interfaces are not used.

	ret = iLdd.SetInterface(0, ifc, bandwidthPriority);

	LOGTEXT2(_L8("<<CCdcDataInterface::SetUpInterface ret=%d"), ret);

	return ret;

	}

void CCdcDataInterface::MLSOStateChange(TInt aPacketSize)

	{

	iPacketSize = aPacketSize;

	}

CCdcDataInterface::~CCdcDataInterface()

/**

 * Destructor. Cancel and destroy the child classes.

 */

	{

	LOG_FUNC

	delete iLinkState;

	delete iReadOneOrMoreReader;

	delete iReader;

	delete iWriter;

	delete iDataAvailableNotifier;

	}

void CCdcDataInterface::Write(MWriteObserver& aObserver, 

						  const TDesC8& aDes, 

						  TInt aLen)

/**

 * Write data down the interface

 * 

 * @param aObserver The observer to notify of completion.

 * @param aDes Descriptor containing the data to be sent

 * @param aLen Length of the data to be sent

 */

	{

	LOG_FUNC

	__ASSERT_DEBUG(!iWriteObserver, 

		_USB_PANIC(KAcmPanicCat, EPanicInternalError));

	iWriteObserver = &aObserver;

	__ASSERT_DEBUG(iWriter, _USB_PANIC(KAcmPanicCat, EPanicInternalError));

	if ( iHostCanHandleZLPs )

		{

		// Make sure the driver sends a Zero Length Packet if required (i.e. if the 

		// data size is an exact multiple of the endpoint's packet size). 

		TBool requestZlp = ( aLen % iPacketSize ) ? EFalse : ETrue;

		iWriter->Write(aDes, aLen, requestZlp); 

		}

	else

		{

		iWriter->Write(aDes, aLen, EFalse); 

		}

	LOGTEXT(_L8("<<CCdcDataInterface::Write"));

	}

void CCdcDataInterface::WriteCompleted(TInt aError)

/**

 * Called when a write request completes.

 *

 * @param aError Error.

 */

	{

	LOGTEXT2(_L8(">>CCdcDataInterface::WriteCompleted aError=%d"), aError);

#ifdef __HEADLESS_ACM_TEST_CODE__

	// Issue another Read or ReadOneOrMore as appropriate.

	// If the Write completed with an error, we panic, as it's invalidating 

	// the test.

	__ASSERT_DEBUG(aError == KErrNone, 

		_USB_PANIC(KAcmPanicCat, EPanicInternalError));

	switch ( iHeadlessReadType )

		{

	case ERead:

		LOGTEXT2(_L8("__HEADLESS_ACM_TEST_CODE__- issuing Read for %d bytes"), 

			iHeadlessReadLength);

		__ASSERT_DEBUG(iReader, _USB_PANIC(KAcmPanicCat, EPanicInternalError));

		iReader->Read(iHeadlessAcmBuffer, iHeadlessReadLength);

		break;

	case EReadOneOrMore:

		LOGTEXT2(_L8("__HEADLESS_ACM_TEST_CODE__- issuing ReadOneOrMore for %d bytes"), 

			iHeadlessReadLength);

		__ASSERT_DEBUG(iReadOneOrMoreReader, _USB_PANIC(KAcmPanicCat, EPanicInternalError));

		iReadOneOrMoreReader->ReadOneOrMore(iHeadlessAcmBuffer, iHeadlessReadLength);

		break;

	case EUnknown:

	default:

		_USB_PANIC(KAcmPanicCat, EPanicInternalError);

		break;

		}

#else

	// In case the write observer wants to post another write synchronously on 

	// being informed that this write has completed, use this little 'temp' 

	// fiddle.

	__ASSERT_DEBUG(iWriteObserver, 

		_USB_PANIC(KAcmPanicCat, EPanicInternalError));

	MWriteObserver* temp = iWriteObserver;

	iWriteObserver = NULL;

	LOGTEXT(_L8("\tcalling WriteCompleted on observer"));

	temp->WriteCompleted(aError);

#endif // __HEADLESS_ACM_TEST_CODE__

	LOGTEXT(_L8("<<CCdcDataInterface::WriteCompleted"));

	}

void CCdcDataInterface::CancelWrite()

/**

 * Cancel an outstanding write request

 */

	{

	LOG_FUNC

	__ASSERT_DEBUG(iWriter, _USB_PANIC(KAcmPanicCat, EPanicInternalError));

	iWriter->Cancel();

	iWriteObserver = NULL;

	}

void CCdcDataInterface::Read(MReadObserver& aObserver, 

							 TDes8& aDes, 

							 TInt aMaxLen)

/**

 * Read data from the interface. As the LDD supports an appropriate function, 

 * this request can be passed straight down. 

 *

 * @param aObserver The observer to notify of completion.

 * @param aDes Descriptor to put the read data in

 * @param aMaxLen Number of bytes to read

 */

	{

	LOG_FUNC

#ifdef __HEADLESS_ACM_TEST_CODE__

	LOGTEXT(_L8("__HEADLESS_ACM_TEST_CODE__"));

	// Issue a Read using our special internal buffer.

	iHeadlessReadType = ERead;

	iHeadlessReadLength = aMaxLen;

	static_cast<void>(&aObserver);

	static_cast<void>(&aDes);

	__ASSERT_DEBUG(aMaxLen <= iHeadlessAcmBuffer.MaxLength(), 

		_USB_PANIC(KAcmPanicCat, EPanicInternalError));

	__ASSERT_DEBUG(iReader, _USB_PANIC(KAcmPanicCat, EPanicInternalError));

	iReader->Read(iHeadlessAcmBuffer, aMaxLen);

#else

	__ASSERT_DEBUG(!iReadObserver, 

		_USB_PANIC(KAcmPanicCat, EPanicInternalError));

	iReadObserver = &aObserver;

	__ASSERT_DEBUG(iReader, _USB_PANIC(KAcmPanicCat, EPanicInternalError));

	iReader->Read(aDes, aMaxLen);

#endif // __HEADLESS_ACM_TEST_CODE__

	}

void CCdcDataInterface::ReadOneOrMore(MReadOneOrMoreObserver& aObserver, 

								  TDes8& aDes, 

								  TInt aMaxLen)

/**

 * Read a given amount of data from the interface, but complete if any data 

 * arrives.

 *

 * @param aObserver The observer to notify of completion.

 * @param aDes Descriptor to put the read data in

 * @param aMaxLen Number of bytes to read

 */

	{

	LOG_FUNC

#ifdef __HEADLESS_ACM_TEST_CODE__

	LOGTEXT(_L8("__HEADLESS_ACM_TEST_CODE__"));

	// Issue a ReadOneOrMore using our special internal buffer.

	iHeadlessReadType = EReadOneOrMore;

	iHeadlessReadLength = aMaxLen;

	static_cast<void>(&aObserver);

	static_cast<void>(&aDes);

	__ASSERT_DEBUG(aMaxLen <= iHeadlessAcmBuffer.MaxLength(), 

		_USB_PANIC(KAcmPanicCat, EPanicInternalError));

	__ASSERT_DEBUG(iReadOneOrMoreReader, 

		_USB_PANIC(KAcmPanicCat, EPanicInternalError));

	iReadOneOrMoreReader->ReadOneOrMore(iHeadlessAcmBuffer, aMaxLen);

#else

	__ASSERT_DEBUG(!iReadOneOrMoreObserver, 

		_USB_PANIC(KAcmPanicCat, EPanicInternalError));

	iReadOneOrMoreObserver = &aObserver;

	__ASSERT_DEBUG(iReadOneOrMoreReader, 

		_USB_PANIC(KAcmPanicCat, EPanicInternalError));

	iReadOneOrMoreReader->ReadOneOrMore(aDes, aMaxLen);

#endif // __HEADLESS_ACM_TEST_CODE__

	}

void CCdcDataInterface::ReadOneOrMoreCompleted(TInt aError)

/**

 * The completion function, called when a ReadOneOrMore request is completed 

 * by the LDD.

 *

 * @param aError The result of the read request.

 */

	{

	LOGTEXT2(_L8(">>CCdcDataInterface::ReadOneOrMoreCompleted aError=%d"), 

		aError);

#ifdef __HEADLESS_ACM_TEST_CODE__

	LOGTEXT2(_L8("__HEADLESS_ACM_TEST_CODE__- issuing Write for %d bytes"),

		iHeadlessAcmBuffer.Length());

	// Write back the data just read.

	// If the ReadOneOrMore completed with an error, we panic, as it's 

	// invalidating the test.

	__ASSERT_DEBUG(aError == KErrNone, 

		_USB_PANIC(KAcmPanicCat, EPanicInternalError));

	__ASSERT_DEBUG(iWriter, _USB_PANIC(KAcmPanicCat, EPanicInternalError));

	iWriter->Write(iHeadlessAcmBuffer, iHeadlessAcmBuffer.Length(), EFalse); 

#else

	__ASSERT_DEBUG(iReadOneOrMoreObserver, 

		_USB_PANIC(KAcmPanicCat, EPanicInternalError));

	// See comment in WriteCompleted.

	MReadOneOrMoreObserver* temp = iReadOneOrMoreObserver;

	iReadOneOrMoreObserver = NULL;

	LOGTEXT(_L8("\tcalling ReadOneOrMoreCompleted on observer"));

	temp->ReadOneOrMoreCompleted(aError);

#endif // __HEADLESS_ACM_TEST_CODE__

	LOGTEXT(_L8("<<CCdcDataInterface::ReadOneOrMoreCompleted"));

	}

void CCdcDataInterface::ReadCompleted(TInt aError)

/**

 * Called by the active reader object when it completes.

 *

 * @param aError Error.

 */

	{

	LOGTEXT2(_L8(">>CCdcDataInterface::ReadCompleted aError=%d"), aError);

#ifdef __HEADLESS_ACM_TEST_CODE__

	LOGTEXT2(_L8("__HEADLESS_ACM_TEST_CODE__- issuing Write for %d bytes"),

		iHeadlessAcmBuffer.Length());

	// Write back the data just read.

	// If the Read completed with an error, we panic, as it's invalidating the 

	// test.				 

	__ASSERT_DEBUG(aError == KErrNone,

		_USB_PANIC(KAcmPanicCat, EPanicInternalError));

	__ASSERT_DEBUG(iWriter, _USB_PANIC(KAcmPanicCat, EPanicInternalError));

	iWriter->Write(iHeadlessAcmBuffer, iHeadlessAcmBuffer.Length(), EFalse); 

#else

	__ASSERT_DEBUG(iReadObserver, 

		_USB_PANIC(KAcmPanicCat, EPanicInternalError));

	// See comment in WriteCompleted.

	MReadObserver* temp = iReadObserver;

	iReadObserver = NULL;

	LOGTEXT(_L8("\tcalled ReadCompleted on observer"));

	temp->ReadCompleted(aError);

#endif // __HEADLESS_ACM_TEST_CODE__

	LOGTEXT(_L8("<<CCdcDataInterface::ReadCompleted"));

	}

void CCdcDataInterface::CancelRead()

/**

 * Cancel an outstanding read request

 */

	{

	LOG_FUNC

	__ASSERT_DEBUG(iReader, _USB_PANIC(KAcmPanicCat, EPanicInternalError));

	__ASSERT_DEBUG(iReadOneOrMoreReader, 

		_USB_PANIC(KAcmPanicCat, EPanicInternalError));

	iReader->Cancel();

	iReadOneOrMoreReader->Cancel();

	iReadObserver = NULL;

	iReadOneOrMoreObserver = NULL;

	}

void CCdcDataInterface::GetHostZLPHandlingFromFile()

/**

 * Opens the ECACM.ini file to check on the capabilities of the host device.

 * If the ini file cannot be found or read successfully, the default setting i.e. the

 * host device CANNOT handle Zero Length Packets (set in CCdcAcmClass::ConstructL()),

 * is kept.		

 */

	{

	LOG_FUNC

	CIniFile* iniFile = NULL;

	_LIT(KEcacmIniFilename, "ecacm.ini" );

	_LIT(KEcacmIniFilePath, "\\system\\data\\" );

	TRAPD(error, iniFile = CIniFile::NewL(KEcacmIniFilename, KEcacmIniFilePath));

	if (error == KErrNone)

		{

		TInt hostHandlesZLPs = 1;

		_LIT(KHostUSBDeviceDriver, "HostUSBDeviceDriver");

		_LIT(KCanHandleZLP, "CanHandleZLP");

		if ( iniFile->FindVar(KHostUSBDeviceDriver, KCanHandleZLP(), hostHandlesZLPs))

			{			

			iHostCanHandleZLPs = (( hostHandlesZLPs == 1 ) ? ETrue : EFalse ); 

			LOGTEXT2(_L8("\tecacm.ini: CanHandleZLP=%d"), hostHandlesZLPs);

			}

		delete iniFile;