/*

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

 *

 */

 // This contains implementation for CT_RDevUsbcClientData class

 #include <f32file.h>

 #include <d32usbc.h>

 #include "T_RDevUsbcClientData.h" 

 /*@{*/

 //LITs to identify the commands

 _LIT(KCmdNewL,									"NewL");

 _LIT(KCmdUtilityLoadLogicalDevice, 				"LoadLogicalDevice");

 _LIT(KCmdOpen, 					    			"Open");

 _LIT(KCmdDeviceCaps,							"DeviceCaps");

 _LIT(KCmdUtilitySetEndPoint, 					"SetEndPoint");

 _LIT(KCmdEndpointCaps,							"EndpointCaps");

 _LIT(KCmdSetInterface, 							"SetInterface");

 _LIT(KCmdGetDeviceDescriptorSize,				"GetDeviceDescriptorSize");

 _LIT(KCmdGetDeviceDescriptor,					"GetDeviceDescriptor");

 _LIT(KCmdSetDeviceDescriptor,					"SetDeviceDescriptor");

 _LIT(KCmdDestructor,							"~");

 /*@}*/

 /*@{*/

 //LITs to read from the ini file

 _LIT(KMode, 									"mode");

 _LIT(KDirection, 								"direction");

 _LIT(KBufferingMask, 							"bandwidthBufferingMask");

 _LIT(KSupportsConnect,							"supportsConnect");

 _LIT(KSupportsSelfPowered, 						"supportsSelfPowered");

 _LIT(KSupportsRemoteWakeup, 					"supportsRemoteWakeup");

 _LIT(KUSBVersionLow, 							"USBVersionLow");

 _LIT(KUSBVersionHigh,							"USBVersionHigh");

 _LIT(KVendorIDLow, 								"VendorIDLow");

 _LIT(KVendorIDHigh, 							"VendorIDHigh");

 _LIT(KProductIDLow, 							"ProductIDLow");

 _LIT(KProductIDHigh, 							"ProductIDHigh");

 _LIT(KReleaseNumberLow, 						"ReleaseNumberLow");

 _LIT(KReleaseNumberHigh, 						"ReleaseNumberHigh");

 _LIT(KDriver, 									"driver");

 _LIT(KEXPECTED, 								"expected");

 /*@}*/

 /*@{*/

 _LIT16(interfaceName, "USB interface");

 /*@}*/

 /*@{*/

 _LIT(KResourceDMA, 							"ResourceDMA");

 _LIT(KResourceDoubleBuffering,				"ResourceDoubleBuffering");

 /*@}*/

 const CDataWrapperBase::TEnumEntryTable CT_RDevUsbcClientData::iEUsbcEndpointResource[] = 

 	{ 

 	{ KResourceDMA,					EUsbcEndpointResourceDMA },		// Requests the use of DMA =0

 	{ KResourceDoubleBuffering,		EUsbcEndpointResourceDoubleBuffering },	//Requests the use of double FIFO buffering = 1	

 	};

 /**

  * Two phase constructor

  *

  * @leave	system wide error

  */

 CT_RDevUsbcClientData* CT_RDevUsbcClientData::NewL()

 	{

 	CT_RDevUsbcClientData*	ret=new (ELeave) CT_RDevUsbcClientData();

 	CleanupStack::PushL(ret);

 	ret->ConstructL();

 	CleanupStack::Pop(ret);

 	return ret;

 	}

 /**

  * Protected constructor. First phase construction

  */

 CT_RDevUsbcClientData::CT_RDevUsbcClientData()

 	:

 	iChannel(NULL),

 	iInterface(NULL),

 	iEndpointData(),

 	iConfiguredEndpoints(0),

 	iTxMaxPacketSize(0),

 	iCaps(),

 	iActiveCallback(NULL),

 	iBuffer(NULL),

     iBuffer_verify(NULL),

     iDeviceDescriptorSize(0)

 	{

 	}

 /**

  * Second phase construction

  *

  * @internalComponent

  *

  * @return	N/A

  *

  * @pre		None

  * @post	None

  *

  * @leave	system wide error

  */

 void CT_RDevUsbcClientData::ConstructL()

 	{

 	iActiveCallback = CActiveCallback::NewL(*this);	

 	}

 /**

  * Public destructor

  */

 CT_RDevUsbcClientData::~CT_RDevUsbcClientData()

 	{		

 	// Empty arrays and delete objects

 	DestroyData();

 	if (iActiveCallback)

 		{

 		delete iActiveCallback;

 		iActiveCallback = NULL;

 		}

 	}

 /**

  *  RunL is called when an asynchronous call has completed

  * 

  *  @param aActive - a pointer to an active object

  *  @param aIndex - Index of the asynchronous call

  * 

  */

 void CT_RDevUsbcClientData::RunL(CActive* aActive, TInt aIndex)

 	{

 	INFO_PRINTF1(_L("*START*CT_RDevUsbcClientData::RunL"));

 	DecOutstanding(); // One of the async calls has completed 

 	TBool straySignal = EFalse; 

 	if(aActive == iActiveCallback)

 		{

 		INFO_PRINTF1(_L("Asynchronous task has completed. RunL  called"));

 		}		

 	else

 		{ 

 		ERR_PRINTF1(_L("Stray RunL signal"));

 		SetBlockResult(EFail);

 		straySignal = ETrue;		

 		}

 	if( !straySignal ) 

 		{ 

 		TInt err = aActive->iStatus.Int(); 

 		if( err != KErrNone ) 

 			{ 

 			ERR_PRINTF2(_L("RunL Error %d"), err); 

 			SetAsyncError( aIndex, err );		

 			} 

 		else

 			{ 

 			INFO_PRINTF1(_L("RunL  completed successfully"));

 			}

 		}

 	INFO_PRINTF1(_L("*END*CT_RDevUsbcClientData::RunL"));

 	}

 /**

  * Return a pointer to the object that the data wraps

  *

  * @return	pointer to the object that the data wraps

  */

 TAny* CT_RDevUsbcClientData::GetObject()

 	{

 	return iChannel;

 	}

 /**

  * Returns the wrapper.

  * 

  * @return pointer to the Wrapper class

  */

 /**

  * Process a command read from the ini file

  *

  * @param aCommand			The command to process

  * @param aSection			The section in the ini containing data for the command

  * @param aAsyncErrorIndex	Command index for async calls to return errors to

  * @return					ETrue if the command is processed

  * @leave					System wide error

  */

 TBool CT_RDevUsbcClientData::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt /*aAsyncErrorIndex*/)

 	{

 	TBool ret=ETrue;

 	if(aCommand == KCmdNewL )

 		{

 		DoCmdNewL();

 		}

 	else if(aCommand == KCmdUtilityLoadLogicalDevice)

 		{

 		DoCmdUtilityLoadLogicalDevice(aSection);

 		}

 	else if(aCommand == KCmdOpen)

 		{

 		DoCmdOpen();

 		}

 	else if(aCommand == KCmdDeviceCaps)

 		{

 		DoCmdDeviceCaps(aSection);

 		}	

 	else if(aCommand == KCmdGetDeviceDescriptorSize)

 		{

 		DoCmdGetDeviceDescriptorSize(aSection);

 		}

 	else if(aCommand == KCmdGetDeviceDescriptor)

 		{

 		DoCmdGetDeviceDescriptor(aSection);

 		}

 	else if(aCommand == KCmdSetDeviceDescriptor)

 		{

 		DoCmdSetDeviceDescriptor(aSection);

 		}

 	else if(aCommand == KCmdUtilitySetEndPoint)

 		{

 		DoCmdUtilitySetEndPointL(aSection);

 		}	

 	else if(aCommand == KCmdEndpointCaps)

 		{

 		DoCmdEndpointCaps();

 		}

 	else if(aCommand == KCmdSetInterface)

 		{

 		DoCmdSetInterface(aSection);

 		}	

 	else if(aCommand == KCmdDestructor)

 		{

 		DoCmdDestructor();

 		}

 	else

 		{

 		ERR_PRINTF1(_L("Unknown command"));

 		ret = EFalse;

 		}

 	return ret;

 	}

 /**

  * Creante an object of RDevUsbcClient

  */

 void  CT_RDevUsbcClientData::DoCmdNewL()

 	{

 	INFO_PRINTF1(_L("*START*CT_RDevUsbcClientData::DoCmdNewL"));

 	DestroyData();

 	iChannel = new (ELeave) RDevUsbcClient();

 	INFO_PRINTF1(_L("*END*CT_RDevUsbcClientData::DoCmdNewL"));

 	}

 /**

  * Loads Logical Device for USB.

  */

 void CT_RDevUsbcClientData::DoCmdUtilityLoadLogicalDevice(const TTEFSectionName& aSection)

 	{

 	INFO_PRINTF1(_L("*START*CT_RDevUsbcClientData::DoCmdUtilityLoadLogicalDevice"));

 	TInt error(KErrNone);

 	TBool dataOk = ETrue;

 	TPtrC lddName;

 	TBufC<9> value;	

 	if(!GetStringFromConfig(aSection, KDriver, lddName))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), & KDriver);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}	

 	if(dataOk)

 		{	

 		value = lddName;		

 		INFO_PRINTF2(_L("Driver: %S"), & value);

 		error = User::LoadLogicalDevice(value);		

 		if(error == KErrAlreadyExists)

 			{

 			INFO_PRINTF2(_L("USB - Logical device driver loaded with %d, error will be changed to KErrNone"), error);

 			error = KErrNone;

 			}

 		if(error != KErrNone)

 			{

 			ERR_PRINTF2(_L("USB - Could not load logical device driver. Error %d"), error);

 			}

 		else

 			{

 			INFO_PRINTF2(_L("USB - Logical device driver loaded with %d"), error);

 			}	

 		SetError(error);

 		}		

 	INFO_PRINTF1(_L("*END*CT_RDevUsbcClientData::DoCmdUtilityLoadLogicalDevice"));

 	}

 /**

  * Opens a USB channel 

  */

 void CT_RDevUsbcClientData::DoCmdOpen()

 	{

 	INFO_PRINTF1(_L("*START*CT_RDevUsbcClientData::DoCmdOpen"));

 	// Open USB driver channel

 	TInt error = iChannel->Open(USB::KUSBChannelOpenParameter);

 	if (error != KErrNone)

 		{

 		ERR_PRINTF2(_L("ERROR %d when opening channel"), error);

 		}

 	else

 		{

 		INFO_PRINTF2(_L("Channel open returns: %d "), error);

 		}

 	SetError(error);

 	INFO_PRINTF1(_L("*END*CT_RDevUsbcClientData::DoCmdOpen"));

 	}

 /**

  * Reads device capabilities and verifies them

  * @param aSection		The section in the ini containing data for the command

  */

 void CT_RDevUsbcClientData::DoCmdDeviceCaps(const TTEFSectionName& aSection)

 	{

 	INFO_PRINTF1(_L("*START*CT_RDevUsbcClientData::DoCmdDeviceCaps"));

 	TBool supportsConnect;

 	TBool dataOk = ETrue;

 	if(!GetBoolFromConfig(aSection, KSupportsConnect, supportsConnect))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KSupportsConnect);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	TBool supportsSelfPowered;

 	if(!GetBoolFromConfig(aSection, KSupportsSelfPowered, supportsSelfPowered))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KSupportsSelfPowered);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	TBool supportsRemoteWakeup;

 	if(!GetBoolFromConfig(aSection, KSupportsRemoteWakeup, supportsRemoteWakeup))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KSupportsRemoteWakeup);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	if(dataOk)

 		{

 		TInt error = iChannel->DeviceCaps(iCaps);

 		if (error != KErrNone)

 			{

 			ERR_PRINTF2(_L("Failed to read device caps [%d]"), error);

 			SetError(error);

 			}

 		else

 			{

 			// Check that reported device capabilities are what they should be

 			INFO_PRINTF2(_L("Device supports %d endpoints"), iCaps().iTotalEndpoints );

 			INFO_PRINTF2(_L("Device supports Software-Connect: %s"), iCaps().iConnect ? _S("yes") : _S("no"));

 			if(!iCaps().iConnect && supportsConnect)

 				{

 				ERR_PRINTF1(_L("Device supports Software-Connect feature IS NOT SUPPORTED"));

 				SetBlockResult(EFail);

 				}

 			INFO_PRINTF2(_L("Device is Self-Powered: %s"), iCaps().iSelfPowered ? _S("yes") : _S("no"));

 			if(!iCaps().iSelfPowered && supportsSelfPowered)

 				{

 				ERR_PRINTF1(_L("Device is Self-Powered feature IS NOT SUPPORTED"));

 				SetBlockResult(EFail);

 				}

 			INFO_PRINTF2(_L("Device supports Remote-Wakeup:	%s"),iCaps().iRemoteWakeup ? _S("yes") : _S("no"));

 			if(!iCaps().iRemoteWakeup && supportsRemoteWakeup)

 				{

 				ERR_PRINTF1(_L("Device supports Remote-Wakeup feature IS NOT SUPPORTED"));

 				SetBlockResult(EFail);

 				}

 			}		

 		}

 	INFO_PRINTF1(_L("*END*CT_RDevUsbcClientData::DoCmdDeviceCaps"));

 	}

 /**

  * Reads device endpoint capabilities and prints them

  */

 void CT_RDevUsbcClientData::DoCmdEndpointCaps()

 	{

 	INFO_PRINTF1(_L("*START*CT_RDevUsbcClientData::DoCmdEndpointCaps"));

 	TPtr8 endpointData(reinterpret_cast<TUint8*>(iEndpointData), sizeof(iEndpointData), sizeof(iEndpointData));

 	TInt error = iChannel->EndpointCaps(endpointData);

 	if (error != KErrNone)

 		{

 		ERR_PRINTF2(_L("Failed to read endpoint caps [%d]"), error);

 		SetError(error);

 		}

 	else

 		{

 		INFO_PRINTF1(_L("User endpoint capabilities:"));

 		for (TInt i = 0; i < iCaps().iTotalEndpoints; i++)

 			{

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

 			INFO_PRINTF4(_L("Endpoint %02d: MaxPackeSize=%s TypeDirM = 0x%08x "),

 						i + 1,

 						(caps->iSizes & KUsbEpSizeCont ) ? _S("Continuous") :

 						((caps->iSizes & KUsbEpSize8) ? _S("8 bytes") :

 						((caps->iSizes & KUsbEpSize16) ? _S("16 bytes") :

 						((caps->iSizes & KUsbEpSize32) ? _S("32 bytes") :

 						((caps->iSizes & KUsbEpSize64) ? _S("64 bytes") :

 						((caps->iSizes & KUsbEpSize128) ? _S("128 bytes") :

 						((caps->iSizes & KUsbEpSize256) ? _S("256 bytes") :

 						((caps->iSizes & KUsbEpSize512) ? _S("512 bytes") :

 						((caps->iSizes & KUsbEpSize1023) ? _S("1023 bytes") :

 						((caps->iSizes & KUsbEpSize1024) ? _S("1024 bytes") :

 						_S("Unknown")))))))))),

 						caps->iTypesAndDir);

 			}

 		}

 	INFO_PRINTF1(_L("*END*CT_RDevUsbcClientData::DoCmdEndpointCaps"));

 	}

 /*

  * Inits USB Device Descriptors - Get the device descriptor size

  */

 void CT_RDevUsbcClientData::DoCmdGetDeviceDescriptorSize(const TTEFSectionName& aSection)

 	{	

 	// Read the size of the descriptors and create buffer to store them.

 	INFO_PRINTF1(_L("*START*CT_RDevUsbcClientData::DoCmdGetDeviceDescriptorSize"));

     TInt expected;

     if(!GetIntFromConfig(aSection, KEXPECTED, expected))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KEXPECTED);

 		SetBlockResult(EFail);

 		}

     else

         {

         iDeviceDescriptorSize = 0;

     	INFO_PRINTF1(_L("Initializing device descriptors"));

         INFO_PRINTF1(_L("void CT_RDevUsbcClientData::GetDeviceDescriptorSize() BEGIN"));

     	iChannel->GetDeviceDescriptorSize(iDeviceDescriptorSize);	

         if(expected != iDeviceDescriptorSize)

             {

             ERR_PRINTF3(_L("Expected size != actual size, expected = %d, actual = %d "),expected, iDeviceDescriptorSize);

             SetBlockResult(EFail);

             }

         }

         // initialize buffer which used to verify.

     INFO_PRINTF1(_L("*END*CT_RDevUsbcClientData::DoCmdGetDeviceDescriptorSize"));

 	}

 /**

  * Inits USB Device Descriptors - Get device descriptor

  */

 void CT_RDevUsbcClientData::DoCmdGetDeviceDescriptor(const TTEFSectionName& aSection)

 	{

 	INFO_PRINTF1(_L("*START*CT_RDevUsbcClientData::DoCmdGetDeviceDescriptor"));

     //initialize descriptor buffer.

     TRAPD(error, iBuffer = HBufC8::NewL(iDeviceDescriptorSize));

     if(error != KErrNone || !iBuffer)

     	{

     	ERR_PRINTF2(_L("Failed to initialize device descriptor [%d]"),error);

     	SetError(error);

     	}

     TRAPD(error2, iBuffer_verify = HBufC8::NewL(iDeviceDescriptorSize));

     if(error2 != KErrNone || !iBuffer_verify)

     	{

     	ERR_PRINTF2(_L("Failed to initialize device descriptor [%d]"),error2);

     	SetError(error2);

     	}  

 	TInt err;	

 	TPtr8 devDescrPtr = iBuffer->Des();

 	// Read the current descriptors.	

 	err = iChannel->GetDeviceDescriptor(devDescrPtr);

 	if (err != KErrNone)

 		{

 		ERR_PRINTF2(_L("Failed to get the device descriptor [%d]"),err);

 		SetError(err);

 		}   

     // Read descriptors from ini and compare.

     TInt USBVersionLow;

 	TBool dataOk = ETrue;

 	if(!GetIntFromConfig(aSection, KUSBVersionLow, USBVersionLow))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KUSBVersionLow);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	TInt USBVersionHigh;

 	if(!GetIntFromConfig(aSection, KUSBVersionHigh, USBVersionHigh))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KUSBVersionHigh);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	TInt VendorIDLow;

 	if(!GetIntFromConfig(aSection, KVendorIDLow, VendorIDLow))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KVendorIDLow);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	TInt VendorIDHigh;

 	if(!GetIntFromConfig(aSection, KVendorIDHigh, VendorIDHigh))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KVendorIDHigh);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	// product ID for test device

 	TInt ProductIDLow;

 	if(!GetIntFromConfig(aSection, KProductIDLow, ProductIDLow))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KProductIDLow);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	TInt ProductIDHigh;

 	if(!GetIntFromConfig(aSection, KProductIDHigh, ProductIDHigh))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KProductIDHigh);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	// release number

 	TInt ReleaseNumberLow;

 	if(!GetIntFromConfig(aSection, KReleaseNumberLow, ReleaseNumberLow))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KReleaseNumberLow);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	TInt ReleaseNumberHigh;

 	if(!GetIntFromConfig(aSection, KReleaseNumberHigh, ReleaseNumberHigh))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KReleaseNumberHigh);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}			

 	// Device descriptor data is presented in bytes (Little endian)

 	// defined in the .ini file

 	// The following presents numeric values device uses to introduce

 	// herself to USB host in enumeration process

 	if(dataOk)

 		{

 		TPtr8 devDescrPtr_verify = iBuffer_verify->Des();

 		err = iChannel->GetDeviceDescriptor(devDescrPtr_verify);

 		if (err != KErrNone)

 			{

 			ERR_PRINTF2(_L("Failed to get the device descriptor [%d]"),err);

 			SetError(err);

 			}   

 		// USB version

 		devDescrPtr_verify[USB::KSpecOffset] = USBVersionLow;

 		devDescrPtr_verify[USB::KSpecOffset + 1] = USBVersionHigh;

 		devDescrPtr_verify[USB::KVendorOffset] = VendorIDLow;

 		devDescrPtr_verify[USB::KVendorOffset + 1] = VendorIDHigh;

 		// product ID for test device

 		devDescrPtr_verify[USB::KProductIDOffset] = ProductIDLow;

 		devDescrPtr_verify[USB::KProductIDOffset + 1] = ProductIDHigh;

 		// Set release number

 		devDescrPtr_verify[USB::KReleaseOffset] = ReleaseNumberLow;

 		devDescrPtr_verify[USB::KReleaseOffset + 1] = ReleaseNumberHigh;

         if(devDescrPtr != devDescrPtr_verify)

             {

             ERR_PRINTF1(_L("Expected DeviceDescriptor is not the same as actual. "));

             SetBlockResult(EFail);

             }

 		}	

         delete iBuffer;

 		iBuffer = NULL;

         delete iBuffer_verify;

 		iBuffer_verify = NULL;

 	INFO_PRINTF1(_L("*END*CT_RDevUsbcClientData::DoCmdGetDeviceDescriptor"));

 	}

 /**

  * Inits USB Device Descriptors - Set device descriptor

  * @param aSection - The section in the ini containing data for the command

  */

 void CT_RDevUsbcClientData::DoCmdSetDeviceDescriptor(const TTEFSectionName& aSection)

 	{

 	// USB version

 	INFO_PRINTF1(_L("*START*CT_RDevUsbcClientData::DoCmdSetDeviceDescriptor"));

     iDeviceDescriptorSize = 0;

     INFO_PRINTF1(_L("Initializing device descriptors"));

     iChannel->GetDeviceDescriptorSize(iDeviceDescriptorSize);	

     INFO_PRINTF2(_L("Device descriptor size = %d"), iDeviceDescriptorSize);

     //initialize descriptor buffer.

     TRAPD(err, iBuffer = HBufC8::NewL(iDeviceDescriptorSize));

     if(err != KErrNone || !iBuffer)

     	{

     	ERR_PRINTF2(_L("Failed to initialize device descriptor [%d]"),err);

     	SetError(err);

     	}

 	TInt error;

 	TInt USBVersionLow;

 	TBool dataOk = ETrue;

 	if(!GetIntFromConfig(aSection, KUSBVersionLow, USBVersionLow))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KUSBVersionLow);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	TInt USBVersionHigh;

 	if(!GetIntFromConfig(aSection, KUSBVersionHigh, USBVersionHigh))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KUSBVersionHigh);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	TInt VendorIDLow;

 	if(!GetIntFromConfig(aSection, KVendorIDLow, VendorIDLow))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KVendorIDLow);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	TInt VendorIDHigh;

 	if(!GetIntFromConfig(aSection, KVendorIDHigh, VendorIDHigh))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KVendorIDHigh);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	// product ID for test device

 	TInt ProductIDLow;

 	if(!GetIntFromConfig(aSection, KProductIDLow, ProductIDLow))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KProductIDLow);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	TInt ProductIDHigh;

 	if(!GetIntFromConfig(aSection, KProductIDHigh, ProductIDHigh))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KProductIDHigh);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	// release number

 	TInt ReleaseNumberLow;

 	if(!GetIntFromConfig(aSection, KReleaseNumberLow, ReleaseNumberLow))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KReleaseNumberLow);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	TInt ReleaseNumberHigh;

 	if(!GetIntFromConfig(aSection, KReleaseNumberHigh, ReleaseNumberHigh))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KReleaseNumberHigh);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}			

 	// Device descriptor data is presented in bytes (Little endian)

 	// defined in the .ini file

 	// The following presents numeric values device uses to introduce

 	// herself to USB host in enumeration process

 	if(dataOk)

 		{

 		TPtr8 devDescrPtr = iBuffer->Des();

 		devDescrPtr.FillZ(devDescrPtr.MaxLength());

 		// USB version

 		devDescrPtr[USB::KSpecOffset] = USBVersionLow;

 		devDescrPtr[USB::KSpecOffset + 1] = USBVersionHigh;

 		devDescrPtr[USB::KVendorOffset] = VendorIDLow;

 		devDescrPtr[USB::KVendorOffset + 1] = VendorIDHigh;

 		// product ID for test device

 		devDescrPtr[USB::KProductIDOffset] = ProductIDLow;

 		devDescrPtr[USB::KProductIDOffset + 1] = ProductIDHigh;

 		// Set release number

 		devDescrPtr[USB::KReleaseOffset] = ReleaseNumberLow;

 		devDescrPtr[USB::KReleaseOffset + 1] = ReleaseNumberHigh;

 		INFO_PRINTF1(_L("Setting device descriptors"));

 		// Store the descriptors.

 		error = iChannel->SetDeviceDescriptor(devDescrPtr);

 		if (error != KErrNone)

 			{

 			ERR_PRINTF2(_L("Failed to set the device descriptor [%d]"),error);

 			delete iBuffer;

 			SetError(error);

 			}

 		else

 			{

 			delete iBuffer;

 			iBuffer = NULL;

 			}

 		INFO_PRINTF1(_L("Device descriptors set"));

 		}	

 	INFO_PRINTF1(_L("*END*CT_RDevUsbcClientData::DoCmdSetDeviceDescriptor"));

 	}

 /**

  * Sets USB EndPoints

  * @param aSection - The section in the ini containing data for the command

  */

 void CT_RDevUsbcClientData::DoCmdUtilitySetEndPointL(const TTEFSectionName& aSection)

 	{

 	INFO_PRINTF1(_L("*START*CT_RDevUsbcClientData::DoCmdUtilitySetEndPointL"));

 	TPtrC16 mode;

 	TBool dataOk = ETrue;

 	if(!GetStringFromConfig(aSection, KMode, mode))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KMode);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	TPtrC16 direction;

 	if(!GetStringFromConfig(aSection, KDirection, direction))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KDirection);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	if(dataOk)

 		{

 		TInt error(KErrNone);	

 		if(mode == USB::KEPBulk)

 			{

 			INFO_PRINTF1(_L("Selected mode is KEPBulk"));

 			if(direction == USB::KEPIn)

 				{

 				error = SetEndpoint(KUsbEpTypeBulk, KUsbEpDirIn);

 				if (error != KErrNone)

 					{

 					ERR_PRINTF2(_L("Failed to set end point direction to KEPIn with error [%d]"), error);

 					SetBlockResult(EFail);					

 					}

 				}

 			else if(direction == USB::KEPOut)

 				{

 				error = SetEndpoint(KUsbEpTypeBulk, KUsbEpDirOut);

 				if (error != KErrNone)

 					{

 					ERR_PRINTF2(_L("Failed to set end point direction to KEPOut with error [%d]"), error);

 					SetBlockResult(EFail);

 					}

 				}

 			else

 				{

 				ERR_PRINTF2(_L("USB - INCORRECT direction %S"), direction.AllocL());

 				SetBlockResult(EFail);

 				}

 			}

 		else if(mode == USB::KEPInterrupt)

 			{

 			INFO_PRINTF1(_L("Selected mode is KEPInterrupt"));

 			if(direction == USB::KEPIn)

 				{

 				error = SetEndpoint(KUsbEpTypeInterrupt, KUsbEpDirIn);

 				if (error != KErrNone)

 					{

 					ERR_PRINTF2(_L("Failed to set end point direction to KEPIn with error [%d]"), error);

 					SetBlockResult(EFail);

 					}

 				}

 			else if(direction == USB::KEPOut)

 				{

 				error = SetEndpoint(KUsbEpTypeInterrupt, KUsbEpDirOut);

 				if (error != KErrNone)

 					{

 					ERR_PRINTF2(_L("Failed to set end point direction to KEPOut with error [%d]"), error);

 					SetBlockResult(EFail);

 					}

 				}

 			else

 				{

 				ERR_PRINTF2(_L("USB - INCORRECT direction %S"), direction.AllocL());

 				SetBlockResult(EFail);

 				}

 			}

 		else

 			{

 			ERR_PRINTF2(_L("USB - Mode not supported %S"), mode.AllocL());

 			SetBlockResult(EFail);

 			}

 		}			

 	INFO_PRINTF1(_L("*END*CT_RDevUsbcClientData::DoCmdUtilitySetEndPointL"));

 	}

 /**

  * Sets a new endpoint for interface handled by this channel

  * @param aEndpointType - USB endpoint type

  * @param aEndpointDirection - USB endpoint direction	

  */

 TInt CT_RDevUsbcClientData::SetEndpoint(TUint aEndpointType, TUint aEndpointDirection)

 	{

 	INFO_PRINTF1(_L("*START*CT_RDevUsbcClientData::SetEndpoint"));

 	if(iConfiguredEndpoints == KMaxEndpointsPerClient)

 		{

 		ERR_PRINTF2(_L("Maximum number of endpoints [%d] for clients reached "), KMaxEndpointsPerClient);

 		SetBlockResult(EFail);

 		return KErrArgument;

 		}

 	// search for the endpoints that match the settings user has given.

 	for (TInt i = 0; i < iCaps().iTotalEndpoints; ++i)

 		{

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

 		const TInt maximumPacketSize = caps->MaxPacketSize();

 		// Check if endpoint in question matches with parameters we want to use for configuring an endpoint

 		if ( (caps->iTypesAndDir & (aEndpointType | aEndpointDirection)) == (aEndpointType | aEndpointDirection) )

 			{

 			INFO_PRINTF3(_L("Configuring %s endpoint with direction %s"),

 				(aEndpointType == KUsbEpTypeControl) ? _S("Control") :

 				((aEndpointType == KUsbEpTypeIsochronous) ? _S("Isochronous") :

 				((aEndpointType == KUsbEpTypeBulk) ? _S("Bulk") :

 				((aEndpointType == KUsbEpTypeInterrupt) ? _S("Interrupt") :

 				_S("Unknown")))),

 				(aEndpointDirection == KUsbEpDirIn) ? _S("In") :

 				((aEndpointDirection == KUsbEpDirOut) ? _S("Out") :

 				((aEndpointDirection == KUsbEpDirBidirect) ? _S("Bidirectional") :

 				_S("Unknown")))

 				);

 			iInterface().iEndpointData[iConfiguredEndpoints].iType = aEndpointType;

 			iInterface().iEndpointData[iConfiguredEndpoints].iDir = aEndpointDirection;

 			iInterface().iEndpointData[iConfiguredEndpoints].iSize = maximumPacketSize;

 			iTxMaxPacketSize = maximumPacketSize;

 			iConfiguredEndpoints++;

 			break;

 			}

 		}

 	INFO_PRINTF1(_L("*END*CT_RDevUsbcClientData::SetEndpoint"));

 	return KErrNone;

 	}

 /**

  * Sets interface with endpoints configured with CT_RDevUsbcClientData::SetEndpoint

  * Note that endpoints must be set before calling this method

  * 

  * @param aBandwithwidthBufferingMask TInt contains IN and OUT bandwidth buffering masks combined 

  *									 using binary OR operation

  *			NOTE: IT IS TEST CASE SCRIPTERS RESPONSIBILITY TO CHECK VALID (or invalid for negative cases) MASKS

  */

 void CT_RDevUsbcClientData::DoCmdSetInterface(const TTEFSectionName& aSection)

 	{

 	INFO_PRINTF1(_L("*START*CT_RDevUsbcClientData::DoCmdSetInterface"));

 	TInt bandwidthBufferingMask;

 	TBool dataOk = ETrue;

 	if(!GetIntFromConfig(aSection, KBufferingMask, bandwidthBufferingMask))

 		{

 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KBufferingMask);

 		SetBlockResult(EFail);

 		dataOk = EFalse;

 		}

 	if(dataOk)

 		{

 		INFO_PRINTF2(_L("bandwidthBufferingMask %d"), bandwidthBufferingMask);

 		INFO_PRINTF2(_L("Configuring the interface settings with %d endpoints"), iConfiguredEndpoints);

 		if( iConfiguredEndpoints == 0 )

 			{

 			ERR_PRINTF1(_L("No endpoints have been set! Set endpoints before configuring interface"));

 			SetBlockResult(EFail);

 			}

 		else

 			{

 			HBufC16* allocatedName = 0;

 			TRAPD(error, allocatedName = interfaceName().AllocL());

 		    if (error != KErrNone)

 		        {

 		        ERR_PRINTF2(_L("AllocL failed [%d]"), error);

 		        SetBlockResult(EFail);

 		        }

 		    else

 		    	{

 		    	iInterface().iString = allocatedName;

 				iInterface().iTotalEndpointsUsed = iConfiguredEndpoints;

 				iInterface().iClass.iClassNum = 0xff;

 				iInterface().iClass.iSubClassNum = 0xff;

 				iInterface().iClass.iProtocolNum = 0xff;

 				INFO_PRINTF2(_L("Using bandwidth buffering mask 0x%08x"), bandwidthBufferingMask);

 				error = iChannel->SetInterface(0, iInterface, bandwidthBufferingMask);

 				delete allocatedName;

 				allocatedName = NULL;

 				if (error != KErrNone)

 					{

 					ERR_PRINTF2(_L("Failed to set the interface [%d]"), error);

 					SetError(error);

 					}

 				INFO_PRINTF2(_L("SetInterface returns [%d]"), error);

 		    	}			

 			}	    

 		}

 	INFO_PRINTF1(_L("*END*CT_RDevUsbcClientData::DoCmdSetInterface"));

 	}

 /**

  * Tell test class to stop waiting 

  * @param result from callback

  */

 void CT_RDevUsbcClientData::Signal(TInt aResult)

 	{

 	INFO_PRINTF2(_L("Signal %d"),aResult);

 	}

 /**

  * Destroyer

  */

 void  CT_RDevUsbcClientData::DoCmdDestructor()

 	{

 	INFO_PRINTF1(_L("*START*CT_RDevUsbcClientData::DoCmdDestructor"));

 	DestroyData();

 	INFO_PRINTF1(_L("*END*CT_RDevUsbcClientData::DoCmdDestructor"));

 	}

 void CT_RDevUsbcClientData::DestroyData()

 	{

 	if(iChannel)

 		{

 		iChannel->Close();

 		delete iChannel;

 		iChannel = NULL;

 		}

 	}