// 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_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_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()

	{

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

	oUsbOtgDriver.Close();

	}

/* otgActivateOptTestMode

 */ 

TInt COtgRoot::otgActivateOptTestMode()

	{

	TInt err = oUsbOtgDriver.ActivateOptTestMode();

	return(err);

	}

/** otgStartStacks

*/

TInt COtgRoot::otgStartStacks()

	{

	TInt err(oUsbOtgDriver.StartStacks());

	if (err != KErrNone)

		{

		}

	return(err);

	}

/** otgStopStacks

*/ 

void COtgRoot::otgStopStacks()

	{

	oUsbOtgDriver.StopStacks();

	}

/** otgUnloadLdd

*/

void COtgRoot::otgUnloadLdd()

	{

	// code to unload the OTG ldd driver

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

	if (err != KErrNone)

		{

		}

	SetLoaded(EFalse);

	}

/** otgQueueOtgEventRequest

*/

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

	{

	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_VERBOSE2(_L("Queue a Message Request %08X.\n"), (TInt)(&aStatus));

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

	{

	TInt err(0);

	err = oUsbOtgDriver.BusRequest();

	if (err != KErrNone)

		{

		}

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

	{

	TInt err(0);

		err = oUsbOtgDriver.BusRespondSrp();

		if (err != KErrNone)

			{

			}

		return(err);

	}

/** Drop VBus (A-host)

*/	

TInt COtgRoot::otgBusDrop()

	{

	TInt err(0);

	err = oUsbOtgDriver.BusDrop();

	if (err != KErrNone)

		{

		}

	return(err);

	}

/** otgBusClearError

*/

TInt COtgRoot::otgBusClearError()

	{

	TInt err(0);

	err = oUsbOtgDriver.BusClearError();

	if (err != KErrNone)

		{

		}

	return(err);

	}

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

	{

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

	}

void COtgRoot::otgCancelOtgIdPinNotification()

	{

	oUsbOtgDriver.CancelOtgIdPinNotification();

	}

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

                                                TRequestStatus& aStatus

                                               )

	{

	oUsbOtgDriver.QueueOtgVbusNotification(aVbus, aStatus);

	}

void COtgRoot::otgCancelOtgVbusNotification()

	{

	oUsbOtgDriver.CancelOtgVbusNotification();

	}

TBool COtgRoot::otgIdPinPresent()

	{

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

	{

	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) 

	{