// 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:

 // @file testdevicebase.cpp

 // @internalComponent

 // 

 //

 #include "TestDeviceBase.h"

 #include "UsbDescriptorOffsets.h"

 #include "testdebug.h"

 #include <e32test.h>

 #include "softwareconnecttimer.h"

 #include "wakeuptimer.h"

 #include "controltransferrequests.h"

 #include "testinterfacebase.h"

 #include "PBASE-T_USBDI-0486.h"

 #include <e32property.h>

 namespace NUnitTesting_USBDI

 	{

 RUsbTestDevice::RUsbTestDevice()

 : 	iStateWatcher(NULL), 

 	iCurrentState(EUsbcDeviceStateUndefined), 

 	iDeviceEp0(NULL), 

 	iConnectTimer(NULL), iWakeupTimer(NULL),

 	iAuxBuffer(NULL)

 	{

 	}

 RUsbTestDevice::RUsbTestDevice(CBaseTestCase* aTestCase)

 : 	iStateWatcher(NULL), 

 	iCurrentState(EUsbcDeviceStateUndefined), 

 	iDeviceEp0(NULL), 

 	iConnectTimer(NULL), iWakeupTimer(NULL),

 	iAuxBuffer(NULL)

 	{

 	LOG_FUNC	

 	iTestCase = aTestCase;

 	RDebug::Printf("iTestCase = %d", iTestCase);

 	}

 void RUsbTestDevice::ResetState()

 	{

 	iCurrentState = EUsbcDeviceStateUndefined;

 	}

 RUsbTestDevice::~RUsbTestDevice()

 	{

 	LOG_FUNC

 	}

 void RUsbTestDevice::Close()

 	{

 	LOG_FUNC

 	delete iWakeupTimer;

 	delete iConnectTimer;

 	delete iDeviceEp0;

 	delete iStateWatcher;

 	iInterfaces.ResetAndDestroy();

 	iClientDriver.Close(); 

 	if(!iTestCase->IsHost()) // process only started in client rom

 		{

         // create a publish/subscribe key to allow usbhost_usbman to be killed

         // cleanly

         static const TUid KWordOfDeathCat = {0x01066600};

         static const TInt KWordOfDeathKey = 0x01066601;

         static _LIT_SECURITY_POLICY_PASS(KAllowAllPolicy);

         TInt r = RProperty::Define(KWordOfDeathCat, KWordOfDeathKey, RProperty::EInt,KAllowAllPolicy, KAllowAllPolicy, 0);

         if(r != KErrNone)

             {

             RDebug::Print(_L("Could not create the WordOfDeath P&S   (%d)"), r);

             }

 		RDebug::Printf("killing t_usbhost_usbman.exe");

         RProperty::Set(KWordOfDeathCat, KWordOfDeathKey, KErrAbort);   // Send the word of death

         User::After(1000000); //allow time for t_usbhost_usbman.exe to clean up

 		}

 	}

 void RUsbTestDevice::SubscribeToReports(TRequestStatus& aObserverStatus)

 	{

 	LOG_FUNC

 	// Signal the request as pending

 	iObserverStatus = &aObserverStatus;

 	*iObserverStatus = KRequestPending;

 	}

 void RUsbTestDevice::CancelSubscriptionToReports()

 	{

 	LOG_FUNC

 	// Signal the request as cancelled

 	User::RequestComplete(iObserverStatus,KErrCancel);

 	}

 void RUsbTestDevice::OpenL()

 	{

 	LOG_FUNC	

 	TInt err = KErrNone;

 	RDebug::Printf("starting t_usbhost_usbman.exe");

 	TInt r = iOtgUsbMan.Create(_L("t_usbhost_usbman.exe"), _L("client"));

 	gtest(r == KErrNone);

 	iOtgUsbMan.Resume();	

 	User::After(1500000);

 	// Open channel to driver

 	err = iClientDriver.Open(0);

 	if(err != KErrNone)

 		{

 		RDebug::Printf("<Error %d> Unable to open a channel to USB client driver",err);

 		User::Leave(err);

 		}

 	// Hide bus from host while interfaces are being set up

 	err = iClientDriver.DeviceDisconnectFromHost();

 	if(err != KErrNone)

 		{

 		RDebug::Printf("<Error %d> unable to disconnect device from host",err);

 		User::Leave(err);

 		}

 	// Create the client usb state watcher

 	iStateWatcher = CUsbClientStateWatcher::NewL(iClientDriver,*this);

 	// Create the Ep0 reader

 	iDeviceEp0 = CDeviceEndpoint0::NewL(*this);

 	// Create the timer for software connection/disconnection

 	iConnectTimer = CSoftwareConnectTimer::NewL(*this);

 	// Create the timer for remote wakeup events

 	iWakeupTimer = CRemoteWakeupTimer::NewL(*this);

 	_LIT8(KYes, "yes");

 	_LIT8(KNo, "no");

 	User::LeaveIfError(iClientDriver.DeviceCaps(iDeviceCaps));

  	RDebug::Printf("------ USB device capabilities -------");

 	RDebug::Printf("Number of endpoints:                %d",iDeviceCaps().iTotalEndpoints);	

 	RDebug::Printf("Supports Software-Connect:          %S",iDeviceCaps().iConnect ? &KYes() : &KNo());

 	RDebug::Printf("Device is Self-Powered:             %S",iDeviceCaps().iSelfPowered ? &KYes() : &KNo());

 	RDebug::Printf("Supports Remote-Wakeup:             %S",iDeviceCaps().iRemoteWakeup ? &KYes() : &KNo());

 	RDebug::Printf("Supports High-speed:                %S",iDeviceCaps().iHighSpeed ? &KYes() : &KNo());

 	RDebug::Printf("Supports unpowered cable detection: %S",(iDeviceCaps().iFeatureWord1 & KUsbDevCapsFeatureWord1_CableDetectWithoutPower) ? &KYes() : &KNo());

 	RDebug::Printf("--------------------------------------");

 	}

 TInt RUsbTestDevice::SetClassCode(TUint8 aClassCode,TUint8 aSubClassCode,TUint8 aDeviceProtocol)

 	{

 	LOG_FUNC

 	// Get Device descriptor

 	TBuf8<KUsbDescSize_Device> deviceDescriptor;

 	TInt err(iClientDriver.GetDeviceDescriptor(deviceDescriptor));

 	if(err != KErrNone)

 		{

 		RDebug::Printf("<Error %d> Unable to obtain device descriptor",err);

 		}

 	else

 		{

 		deviceDescriptor[KDevDescOffset_bDeviceClass] = aClassCode;

 		deviceDescriptor[KDevDescOffset_bDeviceSubClass] = aSubClassCode;

 		deviceDescriptor[KDevDescOffset_bDeviceProtocol] = aDeviceProtocol;	

 		err = iClientDriver.SetDeviceDescriptor(deviceDescriptor);

 		if(err != KErrNone)

 			{

 			RDebug::Printf("<Error %d> Unable to set the device dsecriptor",err);

 			}

 		}

 	return err;

 	}

 TInt RUsbTestDevice::SetUsbSpecification(TUint16 aSpecification)

 	{

 	LOG_FUNC

 	// Get Device descriptor

 	TBuf8<KUsbDescSize_Device> deviceDescriptor;

 	TInt err(iClientDriver.GetDeviceDescriptor(deviceDescriptor));

 	if(err != KErrNone)

 		{

 		RDebug::Printf("<Error %d> Unable to obtain device descriptor",err);

 		}

 	else

 		{

 		// Set bcdUSB

 		TUint8* p = reinterpret_cast<TUint8*>(&aSpecification);

 		deviceDescriptor[KDevDescOffset_bcdUSB] = *p;

 		deviceDescriptor[KDevDescOffset_bcdUSB+1] = *(p+1);

 		// Symbian currently supports only devices with one configuration by selecting the configurations

 		// that has the lowest power consumption

 		deviceDescriptor[KDevDescOffset_bNumConfigurations] = 0x01;

 		err = iClientDriver.SetDeviceDescriptor(deviceDescriptor);

 		if(err != KErrNone)

 			{

 			RDebug::Printf("<Error %d> Unable to set the device dsecriptor",err);

 			}

 		}

 	return err;

 	}

 TInt RUsbTestDevice::SetVendor(TUint16 aVendorId)

 	{

 	LOG_FUNC

 	// Get Device descriptor

 	TBuf8<KUsbDescSize_Device> deviceDescriptor;

 	TInt err(iClientDriver.GetDeviceDescriptor(deviceDescriptor));

 	if(err != KErrNone)

 		{

 		RDebug::Printf("<Error %d> Unable to obtain device descriptor",err);

 		}

 	else

 		{

 		// Set VID

 		TUint8* p = reinterpret_cast<TUint8*>(&aVendorId);

 		deviceDescriptor[KDevDescOffset_idVendor] = *p;

 		deviceDescriptor[KDevDescOffset_idVendor+1] = *(p+1);

 		err = iClientDriver.SetDeviceDescriptor(deviceDescriptor);

 		if(err != KErrNone)

 			{

 			RDebug::Printf("<Error %d> Unable to set the device descriptor",err);

 			}

 		}

 	return err;

 	}

 TInt RUsbTestDevice::SetProduct(TUint16 aProductId,const TDesC16& aProductString,

 				const TDesC16& aManufacturerString,const TDesC16& aSerialNumberString)

 	{

 	LOG_FUNC

 	// Get Device descriptor

 	TBuf8<KUsbDescSize_Device> deviceDescriptor;

 	TInt err(iClientDriver.GetDeviceDescriptor(deviceDescriptor));

 	if(err != KErrNone)

 		{

 		RDebug::Printf("<Error %d> Unable to obtain device descriptor",err);

 		}

 	else

 		{

 		// Set PID

 		TUint8* p = reinterpret_cast<TUint8*>(&aProductId);

 		deviceDescriptor[KDevDescOffset_idProduct] = *p;

 		deviceDescriptor[KDevDescOffset_idProduct+1] = *(p+1);

 		err = iClientDriver.SetDeviceDescriptor(deviceDescriptor);

 		if(err != KErrNone)

 			{

 			RDebug::Printf("<Error %d> Unable to set the device dsecriptor",err);

 			return err;

 			}

 		RDebug::Printf("Product Identity set");

 		// Product string

 		err = iClientDriver.SetProductStringDescriptor(aProductString);

 		if(err != KErrNone)

 			{

 			RDebug::Printf("<Error %d> Unable to set product string descriptor",err);

 			return err;

 			}

 		// Manufacturer string

 		err = iClientDriver.SetManufacturerStringDescriptor(aManufacturerString);

 		if(err != KErrNone)

 			{

 			RDebug::Printf("<Error %d> Unable to set the manufacturer string descriptor",err);

 			return err;

 			}

 		// Serial number string

 		err = iClientDriver.SetSerialNumberStringDescriptor(aSerialNumberString);

 		if(err != KErrNone)

 			{

 			RDebug::Printf("<Error %d> Unable to set the serial number string descriptor",err);

 			return err;

 			}

 		}

 	return KErrNone;

 	}

 TInt RUsbTestDevice::SetConfigurationString(const TDesC16& aConfigString)

 	{

 	LOG_FUNC

 	TInt err(iClientDriver.SetConfigurationStringDescriptor(aConfigString));

 	if(err != KErrNone)

 		{

 		RDebug::Printf("<Error %d> Unable to set configuration string descriptor",err);

 		}

 	return err;

 	}

 void RUsbTestDevice::AddInterface(CInterfaceBase* aInterface)

 	{

 	LOG_FUNC

 	// Add the interface to the device

 	TInt err = iInterfaces.Append(aInterface);

 	if(err != KErrNone)

 		{

 		RDebug::Printf("<Error %d> Unable to add interface",err);

 		return ReportError(err);

 		}

 	}

 CInterfaceBase& RUsbTestDevice::Interface(TInt aIndex)

 	{

 	return *iInterfaces[aIndex];

 	}

 void RUsbTestDevice::SoftwareConnect()

 	{

 	LOG_FUNC

 	TInt err(iClientDriver.PowerUpUdc());

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

 		{

 		RDebug::Printf("<Error %d> Power Up Udc",err);

 		ReportError(err);

 		}

 	if(iDeviceCaps().iConnect) 

 		{

 		err = iClientDriver.DeviceConnectToHost();

 		if(err != KErrNone)

 			{

 			RDebug::Printf("<Error %d> Unable to connect to the host",err);

 			ReportError(err);

 			}

 		}

 	else

 		{

 		RDebug::Printf("Please connect device to Host");

 		}	

 	}   	

 void RUsbTestDevice::SoftwareDisconnect()

 	{

 	LOG_FUNC

 	if(iDeviceCaps().iConnect) 

 		{

 		TInt err(iClientDriver.DeviceDisconnectFromHost());

 		if(err != KErrNone)

 			{

 			RDebug::Printf("<Error %d> Unable to disconnect from the host",err);

 			ReportError(err);

 			}

 		}

 	else

 		{

 		RDebug::Printf("Please disconnect device from Host");

 		}

 	}       

 void RUsbTestDevice::RemoteWakeup()

 	{

 	LOG_FUNC

 	if(iDeviceCaps().iConnect) 

 		{

 		TInt err(iClientDriver.SignalRemoteWakeup());

 		if(err != KErrNone)

 			{

 			RDebug::Printf("<Error %d> Unable to perform a remote wakeup",err);

 			ReportError(err);

 			}

 		}

 	else

 		{

 		RDebug::Printf("remote wakeup not supported");

 		}

 	}

 TInt RUsbTestDevice::ProcessRequestL(TUint8 aRequest,TUint16 aValue,TUint16 aIndex,

 	TUint16 aDataReqLength,const TDesC8& aPayload)

 	{

 	LOG_FUNC

 	if(aRequest == KVendorEmptyRequest)

 		{

 		// Handle an empty request (i.e. do nothing)

 		AcknowledgeRequestReceived();

 		}

 	else if(aRequest == KVendorReconnectRequest)

 		{

 		// Handle a reconnect requests from the host

 		AcknowledgeRequestReceived();

 		iConnectTimer->SoftwareReConnect(aValue);

 		}

 	else if(aRequest == KVendorDisconnectDeviceAThenConnectDeviceCRequest)

 		{

 		RDebug::Printf("**aRequest == KVendorDisconnectDeviceAThenConnectDeviceCRequest, this = 0x%08x", this);

 		// Handle a reconnect requests from the host		

 		AcknowledgeRequestReceived();			

 		SoftwareDisconnect();	

 		User::After(1000000);

 		//	connect device C now	

 		CUT_PBASE_T_USBDI_0486* iTestCaseT_USBDI_0486 = reinterpret_cast<CUT_PBASE_T_USBDI_0486*>(iTestCase);

 		Close(); 		

 		User::After(3000000);

 		iTestCaseT_USBDI_0486->TestDeviceC()->OpenL(KTestDeviceC_SN);		

 		// Connect the device to the host	

 		iTestCaseT_USBDI_0486->TestDeviceC()->SoftwareConnect();

 		return KErrAbort;

 		}

 	else if(aRequest == KVendorDisconnectDeviceCThenConnectDeviceARequest)

 		{

 		RDebug::Printf("**aRequest == KVendorDisconnectDeviceCThenConnectDeviceARequest, this = 0x%08x", this);

 		// Handle a reconnect requests from the host		

 		AcknowledgeRequestReceived();		

 		SoftwareDisconnect();	

 		User::After(1000000); 

 		//	connect device A now	

 		CUT_PBASE_T_USBDI_0486* iTestCaseT_USBDI_0486 = reinterpret_cast<CUT_PBASE_T_USBDI_0486*>(iTestCase);

 		Close();		

 		User::After(3000000); 		

 		iTestCaseT_USBDI_0486->Cancel();

 		iTestCaseT_USBDI_0486->HandleDeviceDConnection();

 		iTestCaseT_USBDI_0486->TestDeviceD()->OpenL(iTestCaseT_USBDI_0486->TestCaseId());	

 		// Connect the device to the host	

 		iTestCaseT_USBDI_0486->TestDeviceD()->SoftwareConnect();	

 		return KErrAbort;

 		}		

 	else if(aRequest == KVendorTestCasePassed)

 		{ 

 		// Test case has completed successfully 

 		// so report to client test case that host is happy		

 		AcknowledgeRequestReceived();

 		ReportError(KErrNone);

 		}

 	else if(aRequest == KVendorTestCaseFailed)

 		{

 		// The test case has failed, so report to client test case

 		// and display/log the error message

 		AcknowledgeRequestReceived();

 		HBufC16* msg = HBufC16::NewL(aPayload.Length());

 		msg->Des().Copy(aPayload);

 		RDebug::Printf("<Host> Test case failed: %S",msg);

 		delete msg;

 		msg = 0;

 		ReportError(-aValue);

 		}

 	else if(aRequest == KVendorRemoteWakeupRequest)

 		{

 		// Handle a remote wakeup request

 		AcknowledgeRequestReceived();

 		iWakeupTimer->WakeUp(aValue);

 		}

 	else if(aRequest == KVendorPutPayloadRequest)

 		{

 		// Handle a payload request from the host

 		AcknowledgeRequestReceived();

 		RDebug::Printf("Put payload");

 		if(aPayload.Compare(_L8("DEADBEEF")) != 0)

 			{

 			RDebug::Printf("<Error %d> Payload not as expected",KErrCorrupt);

 			ReportError(KErrCorrupt);

 			}

 		}

 	else if(aRequest == KVendorGetPayloadRequest)

 		{

 		// Handle a payload request to the host

 		RDebug::Printf("Get payload");

 		__ASSERT_DEBUG(iAuxBuffer, User::Panic(_L("Trying to write non-allocated buffer"), KErrGeneral));

 		RDebug::Printf("iAuxBuffer = ....");

 		RDebug::RawPrint(*iAuxBuffer);

 		RDebug::Printf("\n");

 		//Perform synchronous write to EP0

 		//This allows the subsequent 'Read' request to

 		//take place

 		TInt ret = iDeviceEp0->SendDataSynchronous(*iAuxBuffer);

 		RDebug::Printf("Write (from device callback) executed with error %d", ret);

 		}

 	else if(aRequest == KVendorUnrespondRequest)

 		{

 		// Do not acknowledge this request

 		RDebug::Printf("Unrespond request: continually NAK the host");

 		}

 	else if(aRequest == KVendorStallRequest)

 		{

 		// Stall the specified endpoint

 		AcknowledgeRequestReceived();

 		RDebug::Printf("Stalling endpoint %d",aValue);

 		}

 	else

 		{

 		// Maybe forward to derived classes

 		}

 	return KErrNone;

 	}

 void RUsbTestDevice::StateChangeL(TUsbcDeviceState aNewState,TInt aChangeCompletionCode)

 	{

 	LOG_FUNC

 	RDebug::Printf("Client state change to %d err=%d",aNewState,aChangeCompletionCode);

 	// Notify the test case of failed state change notification

 	if(aChangeCompletionCode != KErrNone)

 		{

 		return ReportError(aChangeCompletionCode);

 		}

 	// Check the state change

 	if(iCurrentState == EUsbcDeviceStateConfigured)

 		{

 		// Device is already in a fully configured state

 		if(aNewState == EUsbcDeviceStateConfigured)

 			{

 			// Do nothing as this is the current state anyway

 			}

 		else

 			{

 			// The is a state change from EUsbcDeviceStateConfigured to aNewState

 			// so stop reading from control ep0

 			RDebug::Printf("Ignoring control ep0");

 			// Stop reading ep0 directed requests

 			StopEp0Reading();

 			// Update state

 			iCurrentState = aNewState;

 			}

 		}

 	else

 		{

 		// Device is not in a fully configured state

 		if(aNewState == EUsbcDeviceStateConfigured)

 			{

 			// Device has now been placed into a fully configured state by the host

 			// so start reading from control ep0

 			RDebug::Printf("Reading from control ep0");

 			// Start reading ep0 directed requests

 			StartEp0Reading();

 			// Update state

 			iCurrentState = aNewState;

 			}

 		else

 			{

 			// Just update the state

 			iCurrentState = aNewState;

 			}

 		}

 	// Forward the state change notification to derived classes

 	OnStateChangeL(aNewState);

 	}

 void RUsbTestDevice::StartEp0Reading()

 	{

 	LOG_FUNC

 	// Start reading device directed ep0 requests

 	TInt err(iDeviceEp0->Start());

 	if(err != KErrNone)

 		{

 		return ReportError(err);

 		}

 	// Start reading interface directed requests

 	TInt interfaceCount(iInterfaces.Count());

 	for(TInt i=0; i<interfaceCount; i++)

 		{

 		iInterfaces[i]->StartEp0Reading();

 		}

 	}

 void RUsbTestDevice::StopEp0Reading()

 	{

 	LOG_FUNC

 	// Stop reading interface directed requests

 	TInt interfaceCount(iInterfaces.Count());

 	for(TInt i=0; i<interfaceCount; i++)

 		{

 		iInterfaces[i]->StopEp0Reading();

 		}

 	// Stop reading device directed requests from ep0

 	TInt err(iDeviceEp0->Stop());

 	if(err != KErrNone)

 		{

 		return ReportError(err);

 		}

 	}

 void RUsbTestDevice::AcknowledgeRequestReceived()

 	{

 	LOG_FUNC

 	TInt err(iDeviceEp0->Reader().Acknowledge());

 	RDebug::Printf("err = %d",err);

 	if(err != KErrNone)

 		{

 		ReportError(err);

 		}

 	}

 void RUsbTestDevice::ReportError(TInt aCompletionCode)

 	{

 	LOG_FUNC

 	RDebug::Printf("err or aCompletionCode = %d, observer status = %d, KRequestPending = %d",

 			aCompletionCode, iObserverStatus->Int(), KRequestPending);

 	if(*iObserverStatus == KRequestPending)

 		{

 		RDebug::Printf("In complete request");

 		User::RequestComplete(iObserverStatus,aCompletionCode);

 		}

 	}

 	}