// Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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 <usbc.h>

#include <e32utrace.h>

#include "te_setfilterparameters.h"

#include "te_utracecmds.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())

		{

		//__KTRACE_OPT(KPANIC, Kern::Printf("LDD Install: USB Controller Not Present"));

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

	  iBufferBaseEp0(NULL),

	  iBufferSizeEp0(0),

	  iNumberOfEndpoints(0),

	  iHwChunkIN(NULL),

	  iHwChunkOUT(NULL),

	  iHwChunkEp0(NULL),

	  iDeviceState(EUsbcDeviceStateUndefined),

	  iOwnsDeviceControl(EFalse),

	  iAlternateSetting(0),

	  iDeviceStatusNeeded(EFalse),

	  iChannelClosing(EFalse)

	{

	//__KTRACE_OPT(KUSB, Kern::Printf("*** DLddUsbcChannel::DLddUsbcChannel CTOR"));

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

	{

	//__KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::~DLddUsbcChannel()"));

	if (iController)

		{

		iStatusCallbackInfo.Cancel();

		iEndpointStatusCallbackInfo.Cancel();

        iOtgFeatureCallbackInfo.Cancel();

        iCompleteAllCallbackInfo.Cancel();

		AbortInterface();

		DestroyAllInterfaces();

		if (iOwnsDeviceControl)

			{

			iController->ReleaseDeviceControl(this);

			iOwnsDeviceControl = EFalse;

			}

		iController->DeRegisterClient(this);

		DestroyEp0();

		delete iStatusFifo;

		}

	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)

	{

	//__KTRACE_OPT(KUSB, Kern::Printf("LDD DoCreateL 1 Ver = %02d %02d %02d",

								//	aVer.iMajor, aVer.iMinor, aVer.iBuild));

	if (!Kern::CurrentThreadHasCapability(ECapabilityCommDD,

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

		{

		return KErrPermissionDenied;

		}

	iController = DUsbClientController::UsbcControllerPointer();

	if (!iController)

		{

		return KErrGeneral;

		}

    if (!iController->IsActive())

        return KErrDisconnected;

	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

    iCompleteAllCallbackInfo.SetDfcQ(iDfcQ);

    iController->RegisterClientCallback(iCompleteAllCallbackInfo);

	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

	iController->RegisterForStatusChange(iStatusCallbackInfo);	// let the ldd start seeing device state changes

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

				{

				TInt r = DoCancel(reqNo);

				if (r == KErrNone)

					r = KErrCancel;

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

				}

			b <<= 1;

			}

		m.Complete(KErrNone, ETrue);

		return;

		}

	if (!iController->IsActive())

		{

        if (id != RDevUsbcClient::EControlEnableUsbDriver)

		    {

            //__KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::HandleMsg - Controller is not active"));

            m.Complete(KErrDisconnected, ETrue);

		    return;

		    }

		}

	if (id < 0)

		{

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

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

	{

	__KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::RequestUserHandle"));

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

//

	{

	// Check on request status

	if (aReqNo <= KUsbcMaxRequests)

		{

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

				}

			else

				{

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

				}

			if (needsCompletion)

				{

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

				}

			}

		}

	else

		{

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

		}

	}

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.

	//     2) Do NOT complete here AT ALL.

	//

	aNeedsCompletion = EFalse;

	TInt r = KErrNone;

	switch (aReqNo)

		{

	case RDevUsbcClient::ERequestAlternateDeviceStatusNotify:

		{

		//__KTRACE_OPT(KUSB, Kern::Printf("EControlReqDeviceStatusNotify"));

		if (a1 != NULL)

			{

			iDeviceStatusNeeded = ETrue;

			iStatusChangePtr = a1;

			aNeedsCompletion = AlternateDeviceStateTestComplete();

			}

		else

			r = KErrArgument;

		break;

		}

	case RDevUsbcClient::ERequestReEnumerate:

		{

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

		// If successful, this will complete via the status notification.

		r = iController->ReEnumerate();

		break;

		}

	case RDevUsbcClient::ERequestEndpointStatusNotify:

		{

		//__KTRACE_OPT(KUSB, Kern::Printf("ERequestEndpointStatusNotify"));

		if (a1 != NULL)

			{

			iEndpointStatusChangePtr = a1;

            iController->RegisterForEndpointStatusChange(iEndpointStatusCallbackInfo);

			}

		else

			r = KErrArgument;

		break;

			}

	case RDevUsbcClient::ERequestOtgFeaturesNotify:

		{

		//__KTRACE_OPT(KUSB, Kern::Printf("ERequestOtgFeaturesNotify"));

		if (a1 != NULL)

			{

            iOtgFeatureChangePtr = a1;

            iController->RegisterForOtgFeatureChange(iOtgFeatureCallbackInfo);

            }

		else

			r = KErrArgument;

        break;

        }

    default:

		r = KErrNotSupported;

		}

	aNeedsCompletion = aNeedsCompletion || (r != KErrNone);

	return r;

	}

TInt DLddUsbcChannel::DoTransferAsyncReq(TInt aEndpointNum, TAny* a1, TAny* a2, TBool& aNeedsCompletion)

	{

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

	// however, those that are returning 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..

	//		2) Do NOT complete here AT ALL.

	//

	aNeedsCompletion = EFalse;

	TInt r = KErrNone;

	TUsbcEndpoint* pEndpoint = NULL;

	TUsbcEndpointInfo* pEndpointInfo = NULL;

	TEndpointTransferInfo* pTfr = NULL;

	if (aEndpointNum == 0)

		{

		// ep0 requests

		if (!(iValidInterface || iOwnsDeviceControl))

			{

			r = KErrUsbInterfaceNotReady;

			goto exit;

			}

		}

	else

		{

		// other eps

		if (!(iValidInterface && (iDeviceState == EUsbcDeviceStateConfigured ||

		                          iDeviceState == EUsbcDeviceStateSuspended))

		   )

			{

			r = KErrUsbInterfaceNotReady;

			goto exit;

			}

		}

	if (!ValidEndpoint(aEndpointNum))

		{

		r = KErrUsbEpNotInInterface;

		goto exit;

 		}

	if (a1 == NULL)

		{

		r = KErrArgument;

		goto exit;

		}

	TEndpointTransferInfo transferInfo;

	pTfr = &transferInfo;

	r = Kern::ThreadRawRead(iClient, a1, pTfr, sizeof(TEndpointTransferInfo));

	if (r != KErrNone)

		PanicClientThread(r);

	pEndpoint = iEndpoint[aEndpointNum];

	if (!pEndpoint)

		{

		r = KErrUsbEpNotInInterface;

		goto exit;

		}

	pEndpointInfo = pEndpoint->EndpointInfo();

	switch (pTfr->iTransferType)

		{

	case ETransferTypeReadData:

	case ETransferTypeReadPacket:

	case ETransferTypeReadUntilShort:

	case ETransferTypeReadOneOrMore:

		{

		if (pEndpoint->iDmaBuffers->RxIsActive())

			{

			//__KTRACE_OPT(KUSB, Kern::Printf("**** ReadReq ep%d RxActive", aEndpointNum));

			}

		else

			{

			//__KTRACE_OPT(KUSB, Kern::Printf("**** ReadReq ep%d RxInActive", aEndpointNum));

			}

		if (pEndpointInfo->iDir != KUsbEpDirOut &&

			pEndpointInfo->iDir != KUsbEpDirBidirect)

			{

			// Trying to do the wrong thing

			r = KErrUsbEpBadDirection;

			break;

			}

		// Set the length of data to zero now to catch all cases

		TPtrC8 pZeroDesc(NULL, 0);

		// Set client descriptor length to zero

		r = Kern::ThreadDesWrite(iClient, pTfr->iDes, pZeroDesc, 0, 0, iClient);

		if (r != KErrNone)

			PanicClientThread(r);

		pEndpoint->SetTransferInfo(pTfr);

		if (pEndpoint->iDmaBuffers->IsReaderEmpty())

			{