// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// @internalComponent

// 

//

#include <e32std.h>

#include <e32std_private.h>

#include <u32std.h> 	// unicode builds

#include <e32base.h>

#include <e32base_private.h>

#include <e32cons.h>

#include <e32Test.h>	// RTest header

#include <e32def.h>

#include <e32def_private.h>

#include <d32otgdi.h>		// OTGDI header

#include <d32usbc.h>		// USBCC header

#include "otgroot.h"

#include "testcaseroot.h"

RUsbOtgDriver  oUsbOtgDriver;

RDevUsbcClient oUsbcClient;

//=====================================================================================

/*	this class wraps all OTGDI calls as well to simplify 

	 calling and normalising object access. - it has no base-class hence we can use multiple-inheritance

	 */	

	COtgRoot::COtgRoot()

	{

	iOptActive = EFalse;

	SetLoaded(EFalse);	

	}

/** otgLoadLdd

*/

TInt COtgRoot::otgLoadLdd()

	{

	LOG_FUNC

	LOG_VERBOSE2(_L("Load driver: %S\n"), &KOTGDeviceInterfaceDriverName);

	if (!LddLoaded())

		{

	 	// load ldd device drivers (load otg only, it will load the needed stuff for us)

		TInt err(User::LoadLogicalDevice(KOTGDeviceInterfaceDriverName));

		if ( (err != KErrNone) && (err != KErrAlreadyExists) )

			{

			test.Printf(_L("<Error %d> Unable to load driver: %S\n"), err, &KOTGDeviceInterfaceDriverName);

			SetLoaded(EFalse);

			return(err);

			}

		else

			{

			LOG_VERBOSE2(_L("Loaded driver: '%S' OK\n"), &KOTGDeviceInterfaceDriverName);

			SetLoaded(ETrue);

			}

		}

		return(KErrNone);

	}

/** otgOpen

*/

TInt COtgRoot::otgOpen()

	{

	LOG_FUNC

	LOG_VERBOSE2(_L("Opening session... loaded = %d\n"), LddLoaded());

	TInt err(oUsbOtgDriver.Open());

	if (err != KErrNone)

		{

		test.Printf(_L("<Error %d> Unable to open a channel to USB OTG driver\n"),err);

		return(err);

		}

	else

		{

		LOG_VERBOSE1(_L("Open channel OK\n"));

		}

	return(KErrNone);	

	}

/** otgClose

*/

void COtgRoot::otgClose()

	{

	LOG_FUNC

	test.Printf(_L("Closing session... loaded = %d\n"), LddLoaded());

	oUsbOtgDriver.Close();

	}

/* otgActivateOptTestMode

 */ 

TInt COtgRoot::otgActivateOptTestMode()

	{

	LOG_FUNC

	TInt err = oUsbOtgDriver.ActivateOptTestMode();

	return(err);

	}

/** otgStartStacks

*/

TInt COtgRoot::otgStartStacks()

	{

	LOG_FUNC

	TInt err(oUsbOtgDriver.StartStacks());

	if (err != KErrNone)

		{

		LOG_FUNCERROR(err)

		}

	return(err);

	}

/** otgStopStacks

*/ 

void COtgRoot::otgStopStacks()

	{

	LOG_FUNC

	oUsbOtgDriver.StopStacks();

	}

/** otgUnloadLdd

*/

void COtgRoot::otgUnloadLdd()

	{

	// code to unload the OTG ldd driver

	TInt err (User::FreeLogicalDevice(KOTGDeviceInterfaceDriverName));

	if (err != KErrNone)

		{

		LOG_FUNCERROR(err)

		}

	SetLoaded(EFalse);

	}

/** otgQueueOtgEventRequest

*/

void COtgRoot::otgQueueOtgEventRequest(RUsbOtgDriver::TOtgEvent& aEvent, TRequestStatus &aStatus)

	{

	//LOG_FUNC	

	LOG_VERBOSE2(_L("Queue an Event Request %08X.\n"), (TInt)(&aStatus));

	oUsbOtgDriver.QueueOtgEventRequest(aEvent, aStatus);

	}

/** otgCancelOtgEventRequest

*/	

void COtgRoot::otgCancelOtgEventRequest()

	{

	LOG_VERBOSE1(_L("Cancel Event Request.\n"));

	oUsbOtgDriver.CancelOtgEventRequest();

	}

/** otgQueueOtgMessageRequest

*/

void COtgRoot::otgQueueOtgMessageRequest(RUsbOtgDriver::TOtgMessage& aMessage, TRequestStatus &aStatus)

	{

	//LOG_FUNC	

	LOG_VERBOSE2(_L("Queue a Message Request %08X.\n"), (TInt)(&aStatus));

	//LOG_VERBOSE1(_L("Queue a Message Request.\n"));

	oUsbOtgDriver.QueueOtgMessageRequest(aMessage, aStatus);

	}

/** otgCancelOtgMessageRequest

*/	

void COtgRoot::otgCancelOtgMessageRequest()

	{

	LOG_VERBOSE1(_L("Cancel Message Request.\n"));

	oUsbOtgDriver.CancelOtgMessageRequest();

	}    

void COtgRoot::otgQueuePeripheralStateRequest(TUint& aPeripheralState, TRequestStatus& aStatus)

	{

	LOG_VERBOSE1(_L("Queue Peripheral State Request.\n"));

	oUsbcClient.AlternateDeviceStatusNotify(aStatus, aPeripheralState);

	}

void COtgRoot::otgCancelPeripheralStateRequest()

	{

	LOG_VERBOSE1(_L("Cancel Peripheral State Request.\n"));

	oUsbcClient.AlternateDeviceStatusNotifyCancel();	

	}

void COtgRoot::otgQueueAConnectionIdleRequest(RUsbOtgDriver::TOtgConnection& aAConnectionIdle, TRequestStatus& aStatus)

	{

	LOG_VERBOSE1(_L("Queue A Connection Idle Request.\n"));

	oUsbOtgDriver.QueueOtgConnectionNotification(aAConnectionIdle, aStatus);

	}

void COtgRoot::otgCancelAConnectionIdleRequest()

	{

	LOG_VERBOSE1(_L("Cancel A Connection Idle Request.\n"));

	oUsbOtgDriver.CancelOtgConnectionNotification();

	}

/** otgQueueOtgStateRequest

*/

void COtgRoot::otgQueueOtgStateRequest(RUsbOtgDriver::TOtgState& aState, TRequestStatus &aStatus)

	{

	//LOG_FUNC	

	LOG_VERBOSE2(_L("Queue a State Request %08X.\n"), (TInt)(&aStatus));

	oUsbOtgDriver.QueueOtgStateRequest(aState, aStatus);

	}

/** otgCancelOtgStateRequest

*/	

void COtgRoot::otgCancelOtgStateRequest()

	{

	LOG_VERBOSE1(_L("Cancel State Request.\n"));

	oUsbOtgDriver.CancelOtgStateRequest();

	}

/** otgBusRequest

raise VBus (in reality this must only happen when a 'A' is present... and when not present it starts HNP)

*/

TInt COtgRoot::otgBusRequest()

	{

	LOG_FUNC

	TInt err(0);

	err = oUsbOtgDriver.BusRequest();

	if (err != KErrNone)

		{

		LOG_FUNCERROR(err)

		}

	return(err);

	}

/* call when SRP has been recieved, based on our HNP Enable setting, this will allow HNP. The 

 * A-device may choose to call BusRequest directly, which will result in a 'short-circuit' role-swap.

 */

TInt COtgRoot::otgBusRespondSRP()

	{

	LOG_FUNC

	TInt err(0);

		err = oUsbOtgDriver.BusRespondSrp();

		if (err != KErrNone)

			{

			LOG_FUNCERROR(err)

			}

		return(err);

	}

/** Drop VBus (A-host)

*/	

TInt COtgRoot::otgBusDrop()

	{

	LOG_FUNC

	TInt err(0);

	err = oUsbOtgDriver.BusDrop();

	if (err != KErrNone)

		{

		LOG_FUNCERROR(err)

		}

	return(err);

	}

/** otgBusClearError

*/

TInt COtgRoot::otgBusClearError()

	{

	LOG_FUNC

	TInt err(0);

	err = oUsbOtgDriver.BusClearError();

	if (err != KErrNone)

		{

		LOG_FUNCERROR(err)

		}

	return(err);

	}

void COtgRoot::otgQueueOtgIdPinNotification(RUsbOtgDriver::TOtgIdPin& aPin, TRequestStatus& aStatus)

	{

	LOG_FUNC

	oUsbOtgDriver.QueueOtgIdPinNotification(aPin, aStatus);	// the kernel driver populates aPin...

	}

void COtgRoot::otgCancelOtgIdPinNotification()

	{

	LOG_FUNC

	oUsbOtgDriver.CancelOtgIdPinNotification();

	}

void COtgRoot::otgQueueOtgVbusNotification(RUsbOtgDriver::TOtgVbus& aVbus, 

                                                TRequestStatus& aStatus

                                               )

	{

	LOG_FUNC

	oUsbOtgDriver.QueueOtgVbusNotification(aVbus, aStatus);

	}

void COtgRoot::otgCancelOtgVbusNotification()

	{

	LOG_FUNC

	oUsbOtgDriver.CancelOtgVbusNotification();

	}

TBool COtgRoot::otgIdPinPresent()

	{

	LOG_FUNC

	TRequestStatus aStatus;

	RUsbOtgDriver::TOtgIdPin aPin;

	oUsbOtgDriver.QueueOtgIdPinNotification(aPin, aStatus);	// the kernel driver populates aPin...

	LOG_VERBOSE2(_L("(sync) ID_PIN=%d\n"), iOTGIdPin);

	oUsbOtgDriver.CancelOtgIdPinNotification();

	// swallow the event

	User::WaitForRequest(aStatus);

	if (RUsbOtgDriver::EIdPinAPlug == aPin)			// at this stage, the aPin value is known

		{

		return(ETrue);

		}

	return(EFalse);

	}

TBool COtgRoot::otgVbusPresent()

	{

	LOG_FUNC

	TRequestStatus aStatus;

 	RUsbOtgDriver::TOtgVbus aVBus;

	oUsbOtgDriver.QueueOtgVbusNotification(aVBus, aStatus);	// the kernel driver populates aPin in a kernel thread...

	oUsbOtgDriver.CancelOtgVbusNotification();

	// swallow the event

	User::WaitForRequest(aStatus);

	if (RUsbOtgDriver::EVbusHigh == aVBus)			// by this stage, the aVBus value is known

		{

		return(ETrue);

		}

	return(EFalse);

	}

TBool COtgRoot::iLoadedLdd = EFalse;

TBool COtgRoot::iFdfActorActive = EFalse;

RProcess COtgRoot::iFdfActorProcess;

/** static */

TBool& COtgRoot::LddLoaded()

	{ 

	return(iLoadedLdd);

	}

/** static */

TBool COtgRoot::SetLoaded(TBool aState) 

	{ 

	iLoadedLdd = aState; 

	return(LddLoaded());

	}

/** static */

void COtgRoot::OtgEventString( RUsbOtgDriver::TOtgEvent aEvent, TBuf<MAX_DSTRLEN> &aDescription)

	{

	switch( aEvent )

		{

		case RUsbOtgDriver::EEventAPlugInserted:		aDescription= _L("A Plug Inserted");break;

		case RUsbOtgDriver::EEventAPlugRemoved:			aDescription= _L("A Plug Removed");	break;

		case RUsbOtgDriver::EEventVbusRaised:			aDescription= _L("VBUS Raised");	break;

		case RUsbOtgDriver::EEventVbusDropped:			aDescription= _L("VBUS Dropped");	break;

		case RUsbOtgDriver::EEventSrpReceived:			aDescription= _L("SRP Received");	break;

		case RUsbOtgDriver::EEventSrpInitiated:			aDescription= _L("SRP Initiated");	break;

		case RUsbOtgDriver::EEventHnpEnabled:			aDescription= _L("HNP Enabled");	break;

		case RUsbOtgDriver::EEventHnpDisabled:			aDescription= _L("HNP Disabled");	break;

		case RUsbOtgDriver::EEventRoleChangedToHost:	aDescription= _L("Role->Host");		break;

		case RUsbOtgDriver::EEventRoleChangedToDevice:	aDescription= _L("Role->Device");	break;

		case RUsbOtgDriver::EEventRoleChangedToIdle:	aDescription= _L("Role->Idle");		break;

		case RUsbOtgDriver::EEventHnpSupported : 		aDescription= _L("HNP Supported");		break;

		case RUsbOtgDriver::EEventHnpAltSupported:		aDescription= _L("Alt-HNP Supp.");		break;

		case RUsbOtgDriver::EEventBusConnectionBusy:	aDescription= _L("Connection Busy");	break;

		case RUsbOtgDriver::EEventBusConnectionIdle:	aDescription= _L("Connection Idle");	break;

		default:										aDescription= _L("Unknown");		break;

		}

	}

/** static */

void COtgRoot::OtgStateString( RUsbOtgDriver::TOtgState aState, TBuf<MAX_DSTRLEN> &aDescription)

	{

	switch( aState )

		{

		case RUsbOtgDriver::EStateReset:		aDescription= _L("Reset");			break;

		case RUsbOtgDriver::EStateAIdle:		aDescription= _L("A-Idle");			break;

		case RUsbOtgDriver::EStateAHost:		aDescription= _L("A-Host");			break;

		case RUsbOtgDriver::EStateAPeripheral:	aDescription= _L("A-Peripheral");	break;

		case RUsbOtgDriver::EStateAVbusError:   aDescription= _L("A-VBus Error");	break;

		case RUsbOtgDriver::EStateBIdle:		aDescription= _L("B-Idle");			break;

		case RUsbOtgDriver::EStateBPeripheral:	aDescription= _L("B-Peripheral");	break;

		case RUsbOtgDriver::EStateBHost:		aDescription= _L("B-Host");			break;

		default:								aDescription= _L("Unknown");		break;

		}

	}

/** static */

void COtgRoot::OtgMessageString( RUsbOtgDriver::TOtgMessage aMessage, TBuf<MAX_DSTRLEN> &aDescription)

	{

	switch( aMessage )

		{

		case RUsbOtgDriver::EEventQueueOverflow:			aDescription = _L("Event Queue Overflow");		break;

		case RUsbOtgDriver::EStateQueueOverflow:			aDescription = _L("State Queue Overflow");		break;

		case RUsbOtgDriver::EMessageQueueOverflow:			aDescription = _L("Message Queue Overflow");	break;

		case RUsbOtgDriver::EMessageBadState:				aDescription = _L("Bad State");					break;

		case RUsbOtgDriver::EMessageStackNotStarted:		aDescription = _L("Stack Not Started");			break;

		case RUsbOtgDriver::EMessageVbusAlreadyRaised:		aDescription = _L("Vbus Already Raised");		break;

		case RUsbOtgDriver::EMessageSrpForbidden:			aDescription = _L("SRP Forbidden");				break;

		case RUsbOtgDriver::EMessageBusControlProblem:		aDescription = _L("Bus Control Problem");		break;

		case RUsbOtgDriver::EMessageVbusError:				aDescription = _L("Vbus Error");				break;

		case RUsbOtgDriver::EMessageSrpTimeout:				aDescription = _L("SRP Timeout");				break;

		case RUsbOtgDriver::EMessageSrpActive:				aDescription = _L("SRP In Use");				break;

		// PREQ 1305 messages

		case RUsbOtgDriver::EMessageSrpNotPermitted:		aDescription = _L("Srp Not Permitted"); break;

		case RUsbOtgDriver::EMessageHnpNotPermitted:		aDescription = _L("Hnp Not Permitted"); break;

		case RUsbOtgDriver::EMessageHnpNotEnabled:			aDescription = _L("Hnp Not Enabled"); break;

		case RUsbOtgDriver::EMessageHnpNotSuspended: 			aDescription = _L("HNP not possible, not suspended"); break;

		case RUsbOtgDriver::EMessageVbusPowerUpNotPermitted:	aDescription = _L("Vbus PowerUp Not Permitted"); break;

		case RUsbOtgDriver::EMessageVbusPowerUpError:			aDescription = _L("Vbus PowerUp Error"); break;

		case RUsbOtgDriver::EMessageVbusPowerDownNotPermitted:	aDescription = _L("Vbus PowerDown Not Permitted"); break;

		case RUsbOtgDriver::EMessageVbusClearErrorNotPermitted:	aDescription = _L("Vbus ClearError Not Permitted"); break;

		case RUsbOtgDriver::EMessageHnpNotResponding:		aDescription = _L("Not reposnding to HNP");

		case RUsbOtgDriver::EMessageHnpBusDrop:				aDescription = _L("VBUS drop during HNP");

		default:												aDescription = _L("Unknown");					break;

		}

	}

void COtgRoot::PeripheralStateString( TUint aPeripheralState, TBuf<MAX_DSTRLEN> &aDescription)

	{

	if(aPeripheralState & KUsbAlternateSetting)

		{

		aDescription = _L("Interface Alternate Setting Change");

		}

	else

		{

		switch( aPeripheralState )

			{

			case EUsbcDeviceStateUndefined:		aDescription = _L("Undefined");			break;

			case EUsbcDeviceStateAttached:		aDescription = _L("Attached");			break;

			case EUsbcDeviceStatePowered:		aDescription = _L("Powered");			break;

			case EUsbcDeviceStateDefault:		aDescription = _L("Default");			break;

			case EUsbcDeviceStateAddress:		aDescription = _L("Addressed");			break;

			case EUsbcDeviceStateConfigured:	aDescription = _L("Configured");		break;

			case EUsbcDeviceStateSuspended:		aDescription = _L("Suspended");			break;

			case EUsbcNoState:					aDescription = _L("NoState!");			break;

			default:							aDescription = _L("Unknown");			break;

			}

		}

	}

void COtgRoot::AConnectionIdleString(RUsbOtgDriver::TOtgConnection aAConnectionIdle, TBuf<MAX_DSTRLEN> &aDescription)

	{

	switch( aAConnectionIdle )

		{

		case RUsbOtgDriver::EConnectionBusy:		aDescription = _L("Busy");			break;

		case RUsbOtgDriver::EConnectionIdle:		aDescription = _L("Idle");			break;

		case RUsbOtgDriver::EConnectionUnknown:		aDescription = _L("Unknown");		break;

		default:									aDescription = _L("Not recognised");break;

		}

	}

TInt COtgRoot::otgActivateFdfActor()

	{

	if(iFdfActorActive)

		{

		RDebug::Print(_L("FdfActor already exists!"));

		return KErrAlreadyExists;

		}

	const TUid KFdfSvrUid={0x10282B48};

	const TUidType fdfActorUid(KNullUid, KNullUid, KFdfSvrUid);

	RDebug::Print(_L("About to activate FDF Actor"));