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

// e32/drivers/usbc/d_usbc.cpp

// LDD for USB Device driver stack:

// The channel object.

// 

//

/**

 @file d_usbc.cpp

 @internalTechnology

*/

#include <drivers/usbc.h>

_LIT(KUsbLddName, "Usbc");

static const TInt KUsbRequestCallbackPriority = 2;

// Quick sanity check on endpoint properties

static TBool ValidateEndpoint(const TUsbcEndpointInfo* aEndpointInfo)

	{

	const TUint dir = aEndpointInfo->iDir;

	const TInt size = aEndpointInfo->iSize;

	if (size <= 0)

		return EFalse;

	switch (aEndpointInfo->iType)

		{

	case KUsbEpTypeControl:

		if (dir != KUsbEpDirBidirect || size > 64)

			return EFalse;

		break;

	case KUsbEpTypeIsochronous:

		if ((dir != KUsbEpDirIn && dir != KUsbEpDirOut) || size > 1024)

			return EFalse;

		break;

	case KUsbEpTypeBulk:

		if ((dir != KUsbEpDirIn && dir != KUsbEpDirOut) || size > 512)

			return EFalse;

		break;

	case KUsbEpTypeInterrupt:

		if ((dir != KUsbEpDirIn && dir != KUsbEpDirOut) || size > 1024)

			return EFalse;

		break;

	default:

		return EFalse;

		}

	return ETrue;

	}

/** Real entry point from the Kernel: return a new driver.

 */

DECLARE_STANDARD_LDD()

	{

	return new DUsbcLogDevice;

	}

/** Create a channel on the device.

	@internalComponent

*/

TInt DUsbcLogDevice::Create(DLogicalChannelBase*& aChannel)

	{

	aChannel = new DLddUsbcChannel;

	return aChannel ? KErrNone : KErrNoMemory;

	}

DUsbcLogDevice::DUsbcLogDevice()

      {

	  iParseMask = KDeviceAllowUnit;

	  iUnitsMask = 0xffffffff;								// Leave units decision to the Controller

      iVersion = TVersion(KUsbcMajorVersion, KUsbcMinorVersion, KUsbcBuildVersion);

      }

TInt DUsbcLogDevice::Install()

	{

	// Only proceed if we have the Controller underneath us

	if (!DUsbClientController::UsbcControllerPointer())

		{

		return KErrGeneral;

		}

	return SetName(&KUsbLddName);

	}

//

// Return the USB controller capabilities.

//

void DUsbcLogDevice::GetCaps(TDes8& aDes) const

	{

	TPckgBuf<TCapsDevUsbc> b;

	b().version = iVersion;

	Kern::InfoCopy(aDes, b);

	}

//

// Constructor

//

DLddUsbcChannel::DLddUsbcChannel()

	: iValidInterface(EFalse),

	  iAlternateSettingList(NULL),

	  iCompleteAllCallbackInfo(this, DLddUsbcChannel::EmergencyCompleteDfc, KUsbRequestCallbackPriority),

	  iStatusChangePtr(NULL),

	  iStatusCallbackInfo(this, DLddUsbcChannel::StatusChangeCallback, KUsbRequestCallbackPriority),

	  iEndpointStatusChangePtr(NULL),

	  iEndpointStatusCallbackInfo(this, DLddUsbcChannel::EndpointStatusChangeCallback,

								  KUsbRequestCallbackPriority),

      iOtgFeatureChangePtr(NULL),

      iOtgFeatureCallbackInfo(this, DLddUsbcChannel::OtgFeatureChangeCallback, KUsbRequestCallbackPriority),

	  iNumberOfEndpoints(0),

	  iDeviceState(EUsbcDeviceStateUndefined),

	  iOwnsDeviceControl(EFalse),

	  iAlternateSetting(0),

	  iDeviceStatusNeeded(EFalse),

	  iChannelClosing(EFalse)

	{

	iClient = &Kern::CurrentThread();

	iClient->Open();

	for (TInt i = 1; i <= KMaxEndpointsPerClient; i++)

		{

		iEndpoint[i] = NULL;

		}

	for (TInt i = 1; i < KUsbcMaxRequests; i++)

		{

		iRequestStatus[i] = NULL;

		}

	}

DLddUsbcChannel::~DLddUsbcChannel()

	{

	if (iController)

		{

		iController->DeRegisterClient(this);

		iStatusCallbackInfo.Cancel();

		iEndpointStatusCallbackInfo.Cancel();

        iOtgFeatureCallbackInfo.Cancel();

        iCompleteAllCallbackInfo.Cancel();

		AbortInterface();

		DestroyAllInterfaces();

		if (iOwnsDeviceControl)

			{

			iController->ReleaseDeviceControl(this);

			iOwnsDeviceControl = EFalse;

			}

		DestroyEp0();

		delete iStatusFifo;

		Kern::DestroyClientRequest(iStatusChangeReq);

		Kern::DestroyClientRequest(iEndpointStatusChangeReq);

		Kern::DestroyClientRequest(iOtgFeatureChangeReq);

		Kern::DestroyVirtualPinObject(iPinObj1);

		Kern::DestroyVirtualPinObject(iPinObj2);

		Kern::DestroyVirtualPinObject(iPinObj3);

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

			{

			Kern::DestroyClientBufferRequest(iClientAsynchNotify[i]->iBufferRequest);

			delete iClientAsynchNotify[i];

			}

		}

	Kern::SafeClose((DObject*&)iClient, NULL);

	}

inline TBool DLddUsbcChannel::ValidEndpoint(TInt aEndpoint)

	{

	return (aEndpoint <= iNumberOfEndpoints && aEndpoint >= 0);

	}

//

// Create channel

//

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

	{

	if (!Kern::CurrentThreadHasCapability(ECapabilityCommDD,

										  __PLATSEC_DIAGNOSTIC_STRING("Checked by USBC.LDD (USB Driver)")))

		{

		return KErrPermissionDenied;

		}

	iController = DUsbClientController::UsbcControllerPointer();

	if (!iController)

		{

		return KErrGeneral;

		}

	iStatusFifo = new TUsbcDeviceStatusQueue;

	if (iStatusFifo == NULL)

		{

		return KErrNoMemory;

		}

  	if (!Kern::QueryVersionSupported(TVersion(KUsbcMajorVersion, KUsbcMinorVersion, KUsbcBuildVersion), aVer))

		{

		return KErrNotSupported;

		}

	// set up the correct DFC queue

	SetDfcQ(iController->DfcQ(0));							// sets the channel's dfc queue

	#ifdef DFC_REALTIME_STATE

		iDfcQ.SetRealtimeState(ERealtimeStateOn);

	#endif

    iCompleteAllCallbackInfo.SetDfcQ(iDfcQ);

	iStatusCallbackInfo.SetDfcQ(iDfcQ);						// use the channel's dfcq for this dfc

	iEndpointStatusCallbackInfo.SetDfcQ(iDfcQ);				// use the channel's dfcq for this dfc

    iOtgFeatureCallbackInfo.SetDfcQ(iDfcQ);

	iMsgQ.Receive();										//start up the message q

	TInt r = iController->RegisterClientCallback(iCompleteAllCallbackInfo);

	if (r != KErrNone)

		return r;

	r = iController->RegisterForStatusChange(iStatusCallbackInfo);

	if (r != KErrNone)

		return r;

	r = iController->RegisterForEndpointStatusChange(iEndpointStatusCallbackInfo);

	if (r != KErrNone)

		return r;

	r = iController->RegisterForOtgFeatureChange(iOtgFeatureCallbackInfo);

	if (r != KErrNone)

		return r;

	r = Kern::CreateClientDataRequest(iStatusChangeReq);

	if (r != KErrNone)

		return r;

	r = Kern::CreateClientDataRequest(iEndpointStatusChangeReq);

	if (r != KErrNone)

		return r;

	r = Kern::CreateClientDataRequest(iOtgFeatureChangeReq);

	if (r != KErrNone)

		return r;

	Kern::CreateVirtualPinObject(iPinObj1);

	Kern::CreateVirtualPinObject(iPinObj2);

	Kern::CreateVirtualPinObject(iPinObj3);

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

		{

			iClientAsynchNotify[i] = new TClientAsynchNotify;

			if(iClientAsynchNotify[i] == NULL)

				return KErrNoMemory;

			r = Kern::CreateClientBufferRequest(iClientAsynchNotify[i]->iBufferRequest,1,TClientBufferRequest::EPinVirtual);

			if (r != KErrNone)

				{

				delete iClientAsynchNotify[i];

				iClientAsynchNotify[i]=NULL;

				return r;

				}

		}

	return r;

	}

void DLddUsbcChannel::CompleteBufferRequest(DThread* aThread, TInt aReqNo, TInt aReason)

{

	iRequestStatus[aReqNo]=NULL;

	Kern::QueueBufferRequestComplete(aThread, iClientAsynchNotify[aReqNo]->iBufferRequest, aReason);

}

TClientBuffer * DLddUsbcChannel::GetClientBuffer(TInt aEndpoint)

{

	return iClientAsynchNotify[aEndpoint]->iClientBuffer;

}

//Runs in client thread

TInt DLddUsbcChannel::SendMsg(TMessageBase * aMsg)

{

	TThreadMessage& m=* (TThreadMessage*)aMsg;

	TInt id = m.iValue;

	TInt r = KErrNone;

	//Cancel Request

	if (id == KMaxTInt)

		{

			r = DLogicalChannel::SendMsg(aMsg);

			return r;

		}

	if (id < 0)

		{

		// DoRequest

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

		r = PreSendRequest(aMsg,~id, pS, m.Ptr1(), m.Ptr2());

		if (r == KErrNone)

			{

			r = DLogicalChannel::SendMsg(aMsg);

			}

		}

	else

		{

		//SendControl

		r = SendControl(aMsg);

		}

	return r;

}

TInt DLddUsbcChannel::PreSendRequest(TMessageBase * aMsg,TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)

{

	TInt r = KErrNone;

	if (aReqNo >= KUsbcMaxRequests)

	{

		Kern::RequestComplete(aStatus, KErrNotSupported);

		return KErrNotSupported;

	}

	if (aReqNo > KUsbcMaxEpNumber)//DoOtherAsyncReq

	{

		switch (aReqNo)

		{

			case RDevUsbcClient::ERequestEndpointStatusNotify:

				iEndpointStatusChangeReq->Reset();

				iEndpointStatusChangeReq->SetStatus(aStatus);

				iEndpointStatusChangeReq->SetDestPtr(a1);

			break;

			case RDevUsbcClient::ERequestOtgFeaturesNotify:

				iOtgFeatureChangeReq->Reset();

				iOtgFeatureChangeReq->SetStatus(aStatus);

				iOtgFeatureChangeReq->SetDestPtr(a1);

			break;

			case RDevUsbcClient::ERequestAlternateDeviceStatusNotify:

				iStatusChangeReq->Reset();

				iStatusChangeReq->SetStatus(aStatus);

				iStatusChangeReq->SetDestPtr(a1);

			break;

			case RDevUsbcClient::ERequestReEnumerate://WE use bufferrequest to complete even tho we dont add any buffers

				iClientAsynchNotify[aReqNo]->Reset();

				r=iClientAsynchNotify[aReqNo]->iBufferRequest->StartSetup(aStatus);

				if (r != KErrNone)

					return r;

				iClientAsynchNotify[aReqNo]->iBufferRequest->EndSetup();

			break;

		}

	}

	else //DoTransferAsyncReq

	{

			if(a1 == NULL)

				return KErrArgument;

			iClientAsynchNotify[aReqNo]->Reset();

			r=iClientAsynchNotify[aReqNo]->iBufferRequest->StartSetup(aStatus);

			if (r != KErrNone)

				return r;

			kumemget(&iTfrInfo,a1,sizeof(TEndpointTransferInfo));

			r=iClientAsynchNotify[aReqNo]->iBufferRequest->AddBuffer(iClientAsynchNotify[aReqNo]->iClientBuffer, iTfrInfo.iDes);

			if (r != KErrNone)

				return r;

			iClientAsynchNotify[aReqNo]->iBufferRequest->EndSetup();

			TThreadMessage& m=*(TThreadMessage*)aMsg;

			m.iArg[1] = (TAny*)&iTfrInfo; //Use Channel owned TransfereInfo structure 

	}

	return KErrNone;

}

void DLddUsbcChannel::HandleMsg(TMessageBase* aMsg)

	{

	TThreadMessage& m = *(TThreadMessage*)aMsg;

	TInt id = m.iValue;

	if (id == (TInt) ECloseMsg)

		{

		iChannelClosing = ETrue;

		m.Complete(KErrNone, EFalse);

		return;

		}

	else if (id == KMaxTInt)

		{

		// Cancel request

		TInt mask = m.Int0();

		TInt b = 1;

		for(TInt reqNo = 0; reqNo < KUsbcMaxRequests; reqNo++)

			{

			TRequestStatus* pS = iRequestStatus[reqNo];

			if ((mask & b) && (pS != NULL))

				{

				DoCancel(reqNo);

				}

			b <<= 1;

			}

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

		}

	}

//

// Overriding DObject virtual

//

TInt DLddUsbcChannel::RequestUserHandle(DThread* aThread, TOwnerType /*aType*/)

	{

	// The USB client LDD is not designed for a channel to be shared between

	// threads. It saves a pointer to the current thread when it is opened, and

	// uses this to complete any asynchronous requests.

	// It is therefore not acceptable for the handle to be duplicated and used

	// by another thread:

	if (aThread == iClient)

		{

		return KErrNone;

		}

	else

		{

		return KErrAccessDenied;

		}

	}

//

// Asynchronous requests - overriding pure virtual

//

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

	{

	// Check on request status

		TInt r = KErrNone;

		if (iRequestStatus[aReqNo] != NULL)

			{

			DestroyAllInterfaces();

			PanicClientThread(ERequestAlreadyPending);

			}

		else

			{

			TBool needsCompletion;

			iRequestStatus[aReqNo] = aStatus;

			if (aReqNo > KUsbcMaxEpNumber)

				{

				r = DoOtherAsyncReq(aReqNo, a1, a2, needsCompletion);

				if (needsCompletion)

					{

					switch (aReqNo)

					{

						case RDevUsbcClient::ERequestEndpointStatusNotify:

							iRequestStatus[aReqNo]=NULL;

							Kern::QueueRequestComplete(iClient,iEndpointStatusChangeReq,r);

						break;

						case RDevUsbcClient::ERequestOtgFeaturesNotify:

							iRequestStatus[aReqNo]=NULL;

							Kern::QueueRequestComplete(iClient,iOtgFeatureChangeReq,r);

						break;

						case RDevUsbcClient::ERequestAlternateDeviceStatusNotify:

							iRequestStatus[aReqNo]=NULL;

							Kern::QueueRequestComplete(iClient,iStatusChangeReq,r);

						break;

						case RDevUsbcClient::ERequestReEnumerate:

							iRequestStatus[aReqNo]=NULL;

							Kern::QueueBufferRequestComplete(iClient, iClientAsynchNotify[aReqNo]->iBufferRequest, r);

						break;

					}

				  }

				}

			else

				{

				r = DoTransferAsyncReq(aReqNo, a1, a2, needsCompletion);

				if (needsCompletion)

					{

					//Kern::RequestComplete(iClient, iRequestStatus[aReqNo], r);

					CompleteBufferRequest(iClient, aReqNo, r);

					}

				}

			}

	}

TInt DLddUsbcChannel::DoOtherAsyncReq(TInt aReqNo, TAny* a1, TAny* a2, TBool& aNeedsCompletion)

	{

	// The general assumption is that none of these will complete now.

	// However, those that make this function return something other than

	// KErrNone will get completed by the calling function.

	// So, 1) If you are returning KErrNone but really need to complete because

	//        completion criteria can be met (for example, sufficient data is

	//        available in the buffer) and then set aNeedsCompletion = ETrue.