// Copyright (c) 2004-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:

// f32test\testusbcldd\src\dlddtestusbcchannel.cpp

// 

//

#include "usbcdesc.h"

#include "dtestusblogdev.h"

#include "testusbc.h"

extern TDynamicDfcQue* gDfcQ;

const TUsbcEndpointData DLddTestUsbcChannel::iEndpointData[] =

	{

		{{KUsbEpSize64,	(KUsbEpTypeControl | KUsbEpDirBidirect)}, EFalse},

		{{KUsbEpSize64,	(KUsbEpTypeBulk	   | KUsbEpDirOut)}, EFalse},

		{{KUsbEpSize64,	(KUsbEpTypeBulk	   | KUsbEpDirIn )}, EFalse},

		{{KUsbEpSize64,	(KUsbEpTypeBulk	   | KUsbEpDirOut)}, EFalse},

		{{KUsbEpSize64,	(KUsbEpTypeBulk	   | KUsbEpDirIn )}, EFalse},

		{{KUsbEpNotAvailable, KUsbEpNotAvailable}, EFalse}

	};

// The EKA1 base class needs a DLogicalDevice* for its constructor

DLddTestUsbcChannel::DLddTestUsbcChannel(RPointerArray<DTestUsbcEndpoint>& aEndpoints) :

	iDescriptors(NULL),

	iIfcSet(this, 0),

	iEndpoints(aEndpoints),

	iDeviceState(EUsbcDeviceStateConfigured)

	{

	iClient = &Kern::CurrentThread();

	iClient->Open();

	}

DLddTestUsbcChannel::~DLddTestUsbcChannel()

	{

	}

TInt DLddTestUsbcChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)

    {

	TInt err = KErrNone;

    // Setup LDD for receiving client messages

    SetDfcQ(gDfcQ);

    iMsgQ.Receive();

	_LIT(KEmptyString, "");

	err = iDescriptors.Init(

							TUsbcDeviceDescriptor::New(0, 0, 0, 0, 0, 0, 0, 0),

							TUsbcConfigDescriptor::New(0, ETrue, ETrue, 0),

							TUsbcLangIdDescriptor::New(0),

							TUsbcStringDescriptor::New(KEmptyString),

							TUsbcStringDescriptor::New(KEmptyString),

							TUsbcStringDescriptor::New(KEmptyString),

							TUsbcStringDescriptor::New(KEmptyString)

							);

    return err;

    }

void DLddTestUsbcChannel::HandleMsg(TMessageBase* aMsg)

	{

	TThreadMessage& m = *(TThreadMessage*)aMsg;

	TInt id = m.iValue;

	if (id == (TInt)ECloseMsg)

		{

		m.Complete(KErrNone, EFalse);

		return;

		}

	else if (id == KMaxTInt)

		{

		// Cancel request.

		TInt mask = m.Int0();

		DTestUsbcEndpoint* pEndpoint = NULL;

		switch (mask)

			{

			case RDevUsbcClient::ERequestEp0Cancel:

				pEndpoint = iEndpoints[0];

				pEndpoint->DoCancel();

				break;

			case RDevUsbcClient::ERequestEp1Cancel:

				pEndpoint = iEndpoints[FindRealEndpoint(1)];

				pEndpoint->DoCancel();

				break;

			case RDevUsbcClient::ERequestEp2Cancel:

				pEndpoint = iEndpoints[FindRealEndpoint(2)];

				pEndpoint->DoCancel();

				break;

			case RDevUsbcClient::ERequestEp3Cancel:

				pEndpoint = iEndpoints[FindRealEndpoint(3)];

				pEndpoint->DoCancel();

				break;

			case RDevUsbcClient::ERequestEp4Cancel:

				pEndpoint = iEndpoints[FindRealEndpoint(4)];

				pEndpoint->DoCancel();

				break;

			case RDevUsbcClient::ERequestEp5Cancel:

				pEndpoint = iEndpoints[FindRealEndpoint(5)];

				pEndpoint->DoCancel();

				break;

			case RDevUsbcClient::ERequestAlternateDeviceStatusNotifyCancel:

				CancelAlternateDeviceStatusNotify();

				break;

			default:

				m.Complete(KErrNotSupported, ETrue);

				return;

			}

		m.Complete(KErrNone, ETrue);

		return;

		}

	if (id < 0)

		{

		// DoRequest

		TRequestStatus* pS = (TRequestStatus*)m.Ptr0();

		DoRequest(~id, pS, m.Ptr1(), m.Ptr2());

		m.Complete(KErrNone, ETrue);

		}

	else

		{

		// DoControl

		TInt r = DoControl(id, m.Ptr0(), m.Ptr1());

		m.Complete(r, ETrue);

		}

	}

TInt DLddTestUsbcChannel::DoCancel(TInt /*aReqNo*/)

	{

	return KErrNone;

	}

void DLddTestUsbcChannel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("DoRequest 0x%08x"),aReqNo));

		TInt r = KErrNone;

		//If request is ep number then do a transfer request.

		if(aReqNo > KUsbcMaxEpNumber)

			{

			if (aReqNo == RDevTestUsbcClient::ETestRequestNotifyEndpointStatus)

				{

				__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("ETestRequestNotifyEndpointStatus")));

				r = HostEndpointStatusNotify((TInt)a1, aStatus);

				}

			else if (aReqNo == RDevUsbcClient::ERequestAlternateDeviceStatusNotify)

				{

				__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("ERequestAlternateDeviceStatusNotify")));

				r = SetAlternateDeviceStatusNotify(aStatus, (TUint*)a1);

				}

			else if (aReqNo == RDevUsbcClient::ERequestReEnumerate)

				{

				__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("ERequestReEnumerate")));

				r = ReEnumerate((TRequestStatus*)a1);

				}

			else

				{

				Kern::RequestComplete(iClient, aStatus, KErrNotSupported);

				}

			}

		else

			{

			r = DoTransferAsyncReq(aReqNo, a1, a2, *aStatus);

			}

	if (r != KErrNone)

		{

		Kern::RequestComplete(iClient, aStatus, r);

		}			

	}

TInt DLddTestUsbcChannel::DoControl(TInt aFunction, TAny* a1, TAny* a2)

	{

	TInt r=KErrNone;

	TDes8& a1Buf = *((TDes8*)a1);

	TDes8& a2Buf = *((TDes8*)a2);

	TPtrC8 pZeroDesc(NULL,0);

	switch (aFunction)

		{

	case RDevUsbcClient::EControlEndpointZeroRequestError:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlEndpointZeroRequestError")));

		r = KErrNone;

		break;

		}

	case RDevUsbcClient::EControlEndpointCaps:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlEndpointCaps")));

		r = __THREADWRITE(iClient, a1, pZeroDesc);

		if(r == KErrNone)

			{

			TBuf8<KMaxTUint8> aBuf;

			memclr(&aBuf, sizeof(aBuf));

        	TPtr8 endpointCfg((TUint8*)&aBuf,0,sizeof(aBuf));

			r = Kern::ThreadDesRead(iClient,a1,endpointCfg,0,0);

			if(r == KErrNone)

				{

				endpointCfg.Copy(reinterpret_cast<const TUint8*>(iEndpointData), 

								 Min(endpointCfg.MaxLength(), 

								 sizeof(TUsbcEndpointData[5])));

				r = Kern::ThreadDesWrite(iClient,a1,endpointCfg,0,KTruncateToMaxLength,iClient);

				}

			}

		if(r != KErrNone)

			{

			__THREADPANIC(iClient, r);

			}

		break;

		}

	case RDevUsbcClient::EControlDeviceCaps:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlDeviceCaps")));

		r = __THREADWRITE(iClient, a1, pZeroDesc);

		if(r!=KErrNone) 

			{

			__THREADPANIC(iClient, r);

			}

		TUsbDeviceCaps caps;

		caps().iTotalEndpoints = KMaxEndpointsPerClient;

		caps().iConnect = ETrue;

		caps().iSelfPowered = ETrue;

		caps().iRemoteWakeup = ETrue;

		TBuf8<KMaxTUint8> aBuf;

        memclr(&aBuf, sizeof(aBuf));

 		TPtr8 cfg((TUint8*)&aBuf,0,sizeof(aBuf));

 		r=Kern::ThreadDesRead(iClient,a1,cfg,0,0);

		cfg = caps.Left(Min(caps.Length(), cfg.MaxLength()));

		r=Kern::ThreadDesWrite(iClient,a1,cfg,0,KTruncateToMaxLength,iClient);

		break;

		}

	case RDevUsbcClient::EControlDeviceStatus:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlDeviceStatus")));

		r = __THREADRAWWRITE(iClient, a1, (TUint8*)&iDeviceState, (TInt)sizeof(iDeviceState));

		if(r != KErrNone)

			{

			__THREADPANIC(iClient, r);

			}

		break;

		}

	case RDevUsbcClient::EControlHaltEndpoint:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlHaltEndpoint")));

		r = HaltClearEndpoint(ETrue, (TInt)a1);

		break;

		}

	case RDevUsbcClient::EControlGetDeviceDescriptor:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlGetDeviceDescriptor")));

		r = __THREADWRITE(iClient, a1, pZeroDesc);

		if(r != KErrNone)

			{

			__THREADPANIC(iClient, r);

			}

		r = iDescriptors.GetDeviceDescriptorTC(iClient, a1Buf);

		break;

		}

	case RDevUsbcClient::EControlSetDeviceDescriptor:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlSetDeviceDescriptor")));

		r = iDescriptors.SetDeviceDescriptorTC(iClient, a1Buf);

		break;

		}

	case RDevUsbcClient::EControlGetDeviceDescriptorSize:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlGetDeviceDescriptorSize")));

		if(a1 != NULL)

			{

			const TPtrC8 size(reinterpret_cast<const TUint8*>(&KUsbDescSize_Device), sizeof(KUsbDescSize_Device));

			r = __THREADWRITE(iClient, a1, size);

			}

		else

			{

			r = KErrArgument;

			}

		break;

		}

	case RDevUsbcClient::EControlGetConfigurationDescriptor:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlGetConfigurationDescriptor")));

		r = __THREADWRITE(iClient, a1, pZeroDesc);		// set client descriptor length to zero

		if(r != KErrNone)

			{

			__THREADPANIC(iClient, r);

			}

		r = iDescriptors.GetConfigurationDescriptorTC(iClient, a1Buf);

		break;

		}

	case RDevUsbcClient::EControlSetConfigurationDescriptor:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlSetConfigurationDescriptor")));

		r = iDescriptors.SetConfigurationDescriptorTC(iClient, a1Buf);

		break;

		}

	case RDevUsbcClient::EControlGetConfigurationDescriptorSize:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlGetConfigurationDescriptorSize")));

		if(a1 != NULL)

			{

			const TPtrC8 size(reinterpret_cast<const TUint8*>(&KUsbDescSize_Config), sizeof(KUsbDescSize_Config));

			r = __THREADWRITE(iClient, a1, size);

			}

		else

			{

			r=KErrArgument;

			}

		break;

		}

	case RDevUsbcClient::EControlGetInterfaceDescriptor:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlGetInterfaceDescriptor")));

		r = iDescriptors.GetInterfaceDescriptorTC(iClient, a2Buf, 0, (TInt)a1);

		break;

		}

	case RDevUsbcClient::EControlSetInterfaceDescriptor:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlSetInterfaceDescriptor")));

		TBuf8<KUsbDescSize_Interface> new_ifc;

		r = __THREADWRITE(iClient, a2, new_ifc);

		if (r != KErrNone)

			{

			break;

			}

		r = iDescriptors.SetInterfaceDescriptor(new_ifc, 0, (TInt)a1);

		break;

		}

	case RDevUsbcClient::EControlGetInterfaceDescriptorSize:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlGetInterfaceDescriptorSize")));

		if (a2 != NULL)

			{

			const TPtrC8 size(reinterpret_cast<const TUint8*>(&KUsbDescSize_Interface), sizeof(KUsbDescSize_Interface));

			r = __THREADWRITE(iClient, a2, size);

			}

		else

			{

			r = KErrArgument;

			}

		break;

		}

	case RDevUsbcClient::EControlGetEndpointDescriptor:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlGetEndpointDescriptor")));

		TEndpointDescriptorInfo info;

		r = __THREADRAWREAD(iClient, a1,(TUint8*)&info, (TInt)sizeof(info));

		if(r != KErrNone)

			{

			__THREADPANIC(iClient, r);

			}

		r = iDescriptors.GetEndpointDescriptorTC(iClient, *((TDes8*)info.iArg), 0, info.iSetting, (TUint8)info.iEndpoint);

		}

	case RDevUsbcClient::EControlSetEndpointDescriptor:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlSetEndpointDescriptor")));

		TEndpointDescriptorInfo info;

		r = __THREADRAWREAD(iClient, a1, (TUint8*)&info, (TInt)sizeof(TEndpointDescriptorInfo));

		if(r != KErrNone)

			__THREADPANIC(iClient, r);

		r = iDescriptors.SetEndpointDescriptorTC(iClient, *((TDes8*)info.iArg), 0, info.iSetting, (TUint8)info.iEndpoint);

		break;

		}

	case RDevUsbcClient::EControlGetEndpointDescriptorSize:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlGetEndpointDescriptorSize")));

		TEndpointDescriptorInfo info;

		r = __THREADRAWREAD(iClient, a1, (TUint8*)&info, (TInt)sizeof(TEndpointDescriptorInfo));

		if(r != KErrNone)

			__THREADPANIC(iClient, r);

		TInt s;

		TInt r = iDescriptors.GetEndpointDescriptorSize(0, info.iSetting, (TUint8)info.iEndpoint, s);

		if (r == KErrNone)

			{

			TPtrC8 size(reinterpret_cast<const TUint8*>(&s), sizeof(s));

			r = __THREADWRITE(iClient, &(info.iArg), size);

			}

		break;

		}

	case RDevUsbcClient::EControlSetCSInterfaceDescriptor:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlSetCSInterfaceDescriptor")));

		TCSDescriptorInfo info;

		r = __THREADRAWREAD(iClient, a1, (TUint8*)&info, (TInt)sizeof(TCSDescriptorInfo));

		if(r != KErrNone)

			__THREADPANIC(iClient, r);

		r = iDescriptors.SetCSInterfaceDescriptorTC(iClient, *((TDes8*)info.iArg), 0, info.iSetting, info.iSize);

		}

		break;

	case RDevUsbcClient::EControlDeviceDisconnectFromHost:

		{

		r = KErrNone;

		break;

		}

	case RDevUsbcClient::EControlDeviceConnectToHost:

		{

		r = KErrNone;

		break;

		}

	case RDevUsbcClient::EControlDevicePowerUpUdc:

		{

		r = KErrNone;

		break;

		}

	case RDevUsbcClient::EControlSetInterface:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlSetInterface")));

		TUsbcIfcInfo info;

		r = __THREADRAWREAD(iClient, a2, (TUint8*)&info, (TInt)sizeof(TUsbcIfcInfo));

		if(r != KErrNone)

			__THREADPANIC(iClient, r);

		TUsbcInterfaceInfoBuf* interfaceData = info.iInterfaceData;

		TPtr8* ifcString = info.iString;

		r = SetInterface((TInt)a1, interfaceData, ifcString);

		}

		break;

	case RDevUsbcClient::EControlReleaseInterface:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlReleaseInterface")));

		r = ReleaseInterface((TInt)a1);

		break;

		}

	case RDevUsbcClient::EControlGetManufacturerStringDescriptor:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlGetManufacturerStringDescriptor")));

		r = iDescriptors.GetManufacturerStringDescriptorTC(iClient, a1Buf);

		break;

		}

	case RDevUsbcClient::EControlSetManufacturerStringDescriptor:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlSetManufacturerStringDescriptor")));

		r = iDescriptors.SetManufacturerStringDescriptorTC(iClient, a1Buf);

		break;

		}

	case RDevUsbcClient::EControlGetProductStringDescriptor:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlGetManufacturerStringDescriptor")));

		r = iDescriptors.GetProductStringDescriptorTC(iClient, a1Buf);

		break;

		}

	case RDevUsbcClient::EControlSetProductStringDescriptor:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlSetProductStringDescriptor")));

		r = iDescriptors.SetProductStringDescriptorTC(iClient, a1Buf);

		break;

		}

	case RDevUsbcClient::EControlGetSerialNumberStringDescriptor:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlGetManufacturerStringDescriptor")));

		r = iDescriptors.GetSerialNumberStringDescriptorTC(iClient, a1Buf);

		break;

		}

	case RDevUsbcClient::EControlSetSerialNumberStringDescriptor:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlSetSerialNumberStringDescriptor")));

		r = iDescriptors.SetSerialNumberStringDescriptorTC(iClient, a1Buf);

		break;

		}

	case RDevUsbcClient::EControlGetConfigurationStringDescriptor:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlGetManufacturerStringDescriptor")));

		r = iDescriptors.GetConfigurationStringDescriptorTC(iClient, a1Buf);

		break;

		}

	case RDevUsbcClient::EControlSetConfigurationStringDescriptor:

		{

		__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("EControlSetConfigurationStringDescriptor")));

		r = iDescriptors.SetConfigurationStringDescriptorTC(iClient, a1Buf);

		break;

		}

	case RDevUsbcClient::EControlEndpointStatus:

		{

		TInt ep = (TInt)a1;

		DTestUsbcEndpoint* pEndpoint = iEndpoints[FindRealEndpoint(ep)];

		TEndpointState state = EEndpointStateUnknown;

		if (pEndpoint->IsHalted())

			{

			state = EEndpointStateStalled;

			}

		else

			{

			state = EEndpointStateNotStalled;

			}

		__THREADRAWWRITE(iClient, a2, (TUint8*)&state, (TInt)sizeof(state));		

		break;

		}

	case RDevTestUsbcClient::ETestControlReqEndpointStatusNotify: