/*

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