// 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);