/*

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

#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

 */

	{

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

	iHostCanHandleZLPs = (KUsbAcmHostCanHandleZLPs != 0);

	}

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.

 */

	{

	TUsbDeviceCaps dCaps;

	TInt ret = iLdd.DeviceCaps(dCaps);

	if ( ret )

		{

		return ret;

		}

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

	const TUint KRequiredNumberOfEndpoints = 2;

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

	if ( totalEndpoints < KRequiredNumberOfEndpoints )

		{

		return KErrGeneral;

		}

	// Endpoints

	TUsbcEndpointData data[KUsbcMaxEndpoints];

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

	ret = iLdd.EndpointCaps(dataptr);

	if ( 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;

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

		{

		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;

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

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

	return ret;

	}

void CCdcDataInterface::MLSOStateChange(TInt aPacketSize)

	{

	iPacketSize = aPacketSize;

	}

CCdcDataInterface::~CCdcDataInterface()

/**

 * Destructor. Cancel and destroy the child classes.

 */

	{

	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

 */

	{

	iWriteObserver = &aObserver;

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

		}

	}

void CCdcDataInterface::WriteCompleted(TInt aError)

/**

 * Called when a write request completes.

 *

 * @param aError Error.

 */

	{

#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.

	switch ( iHeadlessReadType )

		{

	case ERead:

		iReader->Read(iHeadlessAcmBuffer, iHeadlessReadLength);

		break;

	case EReadOneOrMore:

		iReadOneOrMoreReader->ReadOneOrMore(iHeadlessAcmBuffer, iHeadlessReadLength);

		break;

	case EUnknown:

	default:

		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.

	MWriteObserver* temp = iWriteObserver;

	iWriteObserver = NULL;

	temp->WriteCompleted(aError);

#endif // __HEADLESS_ACM_TEST_CODE__

	}

void CCdcDataInterface::CancelWrite()

/**

 * Cancel an outstanding write request

 */

	{

	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

 */

	{

#ifdef __HEADLESS_ACM_TEST_CODE__

	// Issue a Read using our special internal buffer.

	iHeadlessReadType = ERead;

	iHeadlessReadLength = aMaxLen;

	static_cast<void>(&aObserver);

	static_cast<void>(&aDes);

	iReader->Read(iHeadlessAcmBuffer, aMaxLen);

#else

	iReadObserver = &aObserver;

	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

 */

	{

#ifdef __HEADLESS_ACM_TEST_CODE__

	// Issue a ReadOneOrMore using our special internal buffer.

	iHeadlessReadType = EReadOneOrMore;

	iHeadlessReadLength = aMaxLen;

	static_cast<void>(&aObserver);

	static_cast<void>(&aDes);

	iReadOneOrMoreReader->ReadOneOrMore(iHeadlessAcmBuffer, aMaxLen);

#else

	iReadOneOrMoreObserver = &aObserver;

	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.

 */

	{

#ifdef __HEADLESS_ACM_TEST_CODE__

	// Write back the data just read.

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

	// invalidating the test.

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