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

// template\template_assp\pa_usbc.cpp

// Platform-dependent USB client controller layer (USB PSL).

// 

//

#include <template_assp.h>									// /assp/template_assp/

#include <template_assp_priv.h>								// /assp/template_assp/

#include <drivers/usbc.h>

#include "pa_usbc.h"										// .

// Debug support

#ifdef _DEBUG

static const char KUsbPanicCat[] = "USB PSL";

#endif

// Define USB_SUPPORTS_PREMATURE_STATUS_IN to enable proper handling of a premature STATUS_IN stage, i.e. a

// situation where the host sends less data than first announced and instead of more data (OUT) will send an

// IN token to start the status stage. What we do in order to implement this here is to prime the TX fifo with

// a ZLP immediately when we find out that we're dealing with a DATA_OUT request. This way, as soon as the

// premature IN token is received, we complete the transaction by sending off the ZLP. If we don't prime the

// TX fifo then there is no way for us to recognise a premature status because the IN token itself doesn't

// raise an interrupt. We would simply wait forever for more data, or rather we would time out and the host

// would move on and send the next Setup packet.

// The reason why we would not want to implement the proper behaviour is this: After having primed the TX fifo

// with a ZLP, it is impossible for a user to reject such a (class/vendor specific) Setup request, basically

// because the successful status stage happens automatically. At the time the user has received and decoded

// the Setup request there's for her no way to stall Ep0 in order to show to the host that this Setup packet

// is invalid or inappropriate or whatever, because she cannot prevent the status stage from happening.

// (All this is strictly true only if the amount of data in the data stage is less than or equal to Ep0's max

//	packet size. However this is almost always the case.)

//#define USB_SUPPORTS_PREMATURE_STATUS_IN

static const TUsbcEndpointCaps DeviceEndpoints[KUsbTotalEndpoints] =

	{

	//                                                      Hardware #    iEndpoints index

	{KEp0MaxPktSzMask,	(KUsbEpTypeControl	   | KUsbEpDirOut)}, //	 0 -  0

	{KEp0MaxPktSzMask,	(KUsbEpTypeControl	   | KUsbEpDirIn )}, //	 0 -  1

	{KUsbEpNotAvailable, KUsbEpNotAvailable},				// --- Not present

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirIn )}, //	 1 -  3

	{KBlkMaxPktSzMask,	(KUsbEpTypeBulk		   | KUsbEpDirOut)}, //	 2 -  4

	{KUsbEpNotAvailable, KUsbEpNotAvailable},				// --- Not present

	{KUsbEpNotAvailable, KUsbEpNotAvailable},				// --- Not present

	{KIsoMaxPktSzMask,	(KUsbEpTypeIsochronous | KUsbEpDirIn )}, //	 3 -  7

	{KIsoMaxPktSzMask,	(KUsbEpTypeIsochronous | KUsbEpDirOut)}, //	 4 -  8

	{KUsbEpNotAvailable, KUsbEpNotAvailable},				// --- Not present

	{KUsbEpNotAvailable, KUsbEpNotAvailable},				// --- Not present

	{KIntMaxPktSzMask,	(KUsbEpTypeInterrupt   | KUsbEpDirIn )}, //	 5 - 11

	};

// --- TEndpoint --------------------------------------------------------------

TEndpoint::TEndpoint()

//

// Constructor

//

	: iRxBuf(NULL), iReceived(0), iLength(0), iZlpReqd(EFalse), iNoBuffer(EFalse), iDisabled(EFalse),

	  iPackets(0), iLastError(KErrNone), iRequest(NULL), iRxTimer(RxTimerCallback, this),

	  iRxTimerSet(EFalse), iRxMoreDataRcvd(EFalse), iPacketIndex(NULL), iPacketSize(NULL)

	{

	__KTRACE_OPT(KUSB, Kern::Printf("TEndpoint::TEndpoint"));

	}

void TEndpoint::RxTimerCallback(TAny* aPtr)

//

// (This function is static.)

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("TEndpoint::RxTimerCallback"));

	TEndpoint* const ep = static_cast<TEndpoint*>(aPtr);

	if (!ep)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: !ep"));

		}

	else if (!ep->iRxTimerSet)

		{

		// Timer 'stop' substitute (instead of stopping it,

		// we just let it expire after clearing iRxTimerSet)

		__KTRACE_OPT(KUSB, Kern::Printf("!ep->iRxTimerSet - returning"));

		}

	else if (!ep->iRxBuf)

		{

		// Request already completed

		__KTRACE_OPT(KUSB, Kern::Printf("!ep->iRxBuf - returning"));

		}

	else if (ep->iRxMoreDataRcvd)

		{

		__KTRACE_OPT(KUSB, Kern::Printf(" > rx timer cb: not yet completing..."));

		ep->iRxMoreDataRcvd = EFalse;

		ep->iRxTimer.Again(KRxTimerTimeout);

		}

	else

		{

		__KTRACE_OPT(KUSB, Kern::Printf(" > rx timer cb: completing now..."));

		*ep->iPacketSize = ep->iReceived;

		ep->iController->RxComplete(ep);

		}

	}

// --- TTemplateAsspUsbcc public ---------------------------------------------------

TTemplateAsspUsbcc::TTemplateAsspUsbcc()

//

// Constructor.

//

	: iCableConnected(ETrue), iBusIsPowered(EFalse),

	  iInitialized(EFalse), iUsbClientConnectorCallback(UsbClientConnectorCallback),

	  iEp0Configured(EFalse)

	{

	__KTRACE_OPT(KUSB, Kern::Printf("TTemplateAsspUsbcc::TTemplateAsspUsbcc"));

	iAssp = static_cast<TemplateAssp*>(Arch::TheAsic());

	iSoftwareConnectable = iAssp->UsbSoftwareConnectable();

	iCableDetectable = iAssp->UsbClientConnectorDetectable();

	if (iCableDetectable)

		{

		// Register our callback for detecting USB cable insertion/removal.

		// We ignore the error code: if the registration fails, we just won't get any events.

		// (Which of course is bad enough...)

		(void) iAssp->RegisterUsbClientConnectorCallback(iUsbClientConnectorCallback, this);

		// Call the callback straight away so we get the proper PIL state from the beginning.

		(void) UsbClientConnectorCallback(this);

		}

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

		{

		iEndpoints[i].iController = this;

		}

	}

TInt TTemplateAsspUsbcc::Construct()

//

// Construct.

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("TTemplateAsspUsbcc::Construct"));

	TUsbcDeviceDescriptor* DeviceDesc = TUsbcDeviceDescriptor::New(

		0x00,												// aDeviceClass

		0x00,												// aDeviceSubClass

		0x00,												// aDeviceProtocol

		KEp0MaxPktSz,										// aMaxPacketSize0

		KUsbVendorId,										// aVendorId

		KUsbProductId,										// aProductId

		KUsbDevRelease,										// aDeviceRelease

		1);													// aNumConfigurations

	if (!DeviceDesc)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for dev desc failed."));

		return KErrGeneral;

		}

	TUsbcConfigDescriptor* ConfigDesc = TUsbcConfigDescriptor::New(

		1,													// aConfigurationValue

		ETrue,												// aSelfPowered (see 12.4.2 "Bus-Powered Devices")

		ETrue,												// aRemoteWakeup

		0);													// aMaxPower (mA)

	if (!ConfigDesc)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for config desc failed."));

		return KErrGeneral;

		}

	TUsbcLangIdDescriptor* StringDescLang = TUsbcLangIdDescriptor::New(KUsbLangId);

	if (!StringDescLang)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for lang id $ desc failed."));

		return KErrGeneral;

		}

	// ('sizeof(x) - 2' because 'wchar_t KStringXyz' created a wide string that ends in '\0\0'.)

	TUsbcStringDescriptor* StringDescManu =

		TUsbcStringDescriptor::New(TPtr8(

									   const_cast<TUint8*>(reinterpret_cast<const TUint8*>(KStringManufacturer)),

									   sizeof(KStringManufacturer) - 2, sizeof(KStringManufacturer) - 2));

	if (!StringDescManu)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for manufacturer $ desc failed."));

		return KErrGeneral;

		}

	TUsbcStringDescriptor* StringDescProd =

		TUsbcStringDescriptor::New(TPtr8(

									   const_cast<TUint8*>(reinterpret_cast<const TUint8*>(KStringProduct)),

									   sizeof(KStringProduct) - 2, sizeof(KStringProduct) - 2));

	if (!StringDescProd)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for product $ desc failed."));

		return KErrGeneral;

		}

	TUsbcStringDescriptor* StringDescSer =

		TUsbcStringDescriptor::New(TPtr8(

									   const_cast<TUint8*>(reinterpret_cast<const TUint8*>(KStringSerialNo)),

									   sizeof(KStringSerialNo) - 2, sizeof(KStringSerialNo) - 2));

	if (!StringDescSer)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for serial no $ desc failed."));

		return KErrGeneral;

		}

	TUsbcStringDescriptor* StringDescConf =

		TUsbcStringDescriptor::New(TPtr8(

									   const_cast<TUint8*>(reinterpret_cast<const TUint8*>(KStringConfig)),

									   sizeof(KStringConfig) - 2, sizeof(KStringConfig) - 2));

	if (!StringDescConf)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for config $ desc failed."));

		return KErrGeneral;

		}

	const TBool r =	InitialiseBaseClass(DeviceDesc,

										ConfigDesc,

										StringDescLang,

										StringDescManu,

										StringDescProd,

										StringDescSer,

										StringDescConf);

	if (!r)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: UsbClientController::InitialiseBaseClass failed."));

		return KErrGeneral;

		}

	return KErrNone;

	}

TTemplateAsspUsbcc::~TTemplateAsspUsbcc()

//

// Destructor.

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("TTemplateAsspUsbcc::~TTemplateAsspUsbcc"));

	// Unregister our callback for detecting USB cable insertion/removal

	if (iCableDetectable)

		{

		iAssp->UnregisterUsbClientConnectorCallback();

		}

	if (iInitialized)

		{

		// (The explicit scope operator is used against Lint warning #1506.)

		TTemplateAsspUsbcc::StopUdc();

		}

	}

TBool TTemplateAsspUsbcc::DeviceStateChangeCaps() const

//

// Returns capability of hardware to accurately track the device state (Chapter 9 state).

//

	{

	// TO DO: Return EFalse or ETrue here, depending on whether the UDC supports exact device state tracking

	// (most don't).

	return EFalse;

	}

TInt TTemplateAsspUsbcc::SignalRemoteWakeup()

//

// Forces the UDC into a non-idle state to perform a remote wakeup operation.

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("TTemplateAsspUsbcc::SignalRemoteWakeup"));

	// TO DO: Do here whatever is necessary for the UDC to signal remote wakeup.

	return KErrNone;

	}

void TTemplateAsspUsbcc::DumpRegisters()

//

// Dumps the contents of a number of UDC registers to the screen (using Kern::Printf()).

// Rarely used, but might prove helpful when needed.

//

	{

	Kern::Printf("TCotullaUsbcc::DumpRegisters:");

	// TO DO: Print the contents of some (or all) UDC registers here.

	}

TDfcQue* TTemplateAsspUsbcc::DfcQ(TInt /* aUnit */)

//

// Returns a pointer to the kernel DFC queue to be used buy the USB LDD.

//

	{

	return Kern::DfcQue0();

	}

// --- TTemplateAsspUsbcc private virtual ------------------------------------------

TInt TTemplateAsspUsbcc::SetDeviceAddress(TInt aAddress)

//

// Sets the PIL-provided device address manually (if possible - otherwise do nothing).

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("TTemplateAsspUsbcc::SetDeviceAddress: %d", aAddress));

	// TO DO (optional): Set device address here.

	if (aAddress)

		{

		// Address can be zero.

		MoveToAddressState();

		}

	return KErrNone;

	}

TInt TTemplateAsspUsbcc::ConfigureEndpoint(TInt aRealEndpoint, const TUsbcEndpointInfo& aEndpointInfo)

//

// Prepares (enables) an endpoint (incl. Ep0) for data transmission or reception.

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("TTemplateAsspUsbcc::ConfigureEndpoint(%d)", aRealEndpoint));

	const TInt n = ArrayIdx2TemplateEp(aRealEndpoint);

	if (n < 0)

		return KErrArgument;

	TEndpoint* const ep = &iEndpoints[aRealEndpoint];

	if (ep->iDisabled == EFalse)

		{

		EnableEndpointInterrupt(n);

		}

	ep->iNoBuffer = EFalse;

	if (n == 0)

		iEp0Configured = ETrue;

	return KErrNone;

	}

TInt TTemplateAsspUsbcc::DeConfigureEndpoint(TInt aRealEndpoint)

//

// Disables an endpoint (incl. Ep0).

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("TTemplateAsspUsbcc::DeConfigureEndpoint(%d)", aRealEndpoint));

	const TInt n = ArrayIdx2TemplateEp(aRealEndpoint);

	if (n < 0)

		return KErrArgument;

	DisableEndpointInterrupt(n);

	if (n == 0)

		iEp0Configured = EFalse;

	return KErrNone;

	}

TInt TTemplateAsspUsbcc::AllocateEndpointResource(TInt aRealEndpoint, TUsbcEndpointResource aResource)

//

// Puts the requested endpoint resource to use, if possible.

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("TTemplateAsspUsbcc::AllocateEndpointResource(%d): %d",

									aRealEndpoint, aResource));

	// TO DO: Allocate endpoint resource here.

	return KErrNone;

	}

TInt TTemplateAsspUsbcc::DeAllocateEndpointResource(TInt aRealEndpoint, TUsbcEndpointResource aResource)

//

// Stops the use of the indicated endpoint resource, if beneficial.

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("TTemplateAsspUsbcc::DeAllocateEndpointResource(%d): %d",

									aRealEndpoint, aResource));

	// TO DO: Deallocate endpoint resource here.

	return KErrNone;

	}

TBool TTemplateAsspUsbcc::QueryEndpointResource(TInt aRealEndpoint, TUsbcEndpointResource aResource) const

//

// Returns the status of the indicated resource and endpoint.

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("TTemplateAsspUsbcc::QueryEndpointResource(%d): %d",

									aRealEndpoint, aResource));

	// TO DO: Query endpoint resource here. The return value should reflect the actual state.

	return ETrue;

	}

TInt TTemplateAsspUsbcc::OpenDmaChannel(TInt aRealEndpoint)

//

// Opens a DMA channel for this endpoint. This function is always called during the creation of an endpoint

// in the PIL. If DMA channels are a scarce resource, it's possible to do nothing here and wait for an

// AllocateEndpointResource call instead.

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("TTemplateAsspUsbcc::OpenDmaChannel(%d)", aRealEndpoint));

	// TO DO (optional): Open DMA channel here.

	// An error should only  be returned in case of an actual DMA problem.

	return KErrNone;

	}

void TTemplateAsspUsbcc::CloseDmaChannel(TInt aRealEndpoint)

//

// Closes a DMA channel for this endpoint. This function is always called during the destruction of an

// endpoint in the PIL.

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("TTemplateAsspUsbcc::CloseDmaChannel(%d)", aRealEndpoint));

	// TO DO (optional): Close DMA channel here (only if it was opened via OpenDmaChannel).

	}

TInt TTemplateAsspUsbcc::SetupEndpointRead(TInt aRealEndpoint, TUsbcRequestCallback& aCallback)

//

// Sets up a read request for an endpoint on behalf of the LDD.

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("TTemplateAsspUsbcc::SetupEndpointRead(%d)", aRealEndpoint));

	if (!IS_OUT_ENDPOINT(aRealEndpoint))

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: !IS_OUT_ENDPOINT(%d)", aRealEndpoint));

		return KErrArgument;

		}

	TEndpoint* const ep = &iEndpoints[aRealEndpoint];

	if (ep->iRxBuf != NULL)

		{

		__KTRACE_OPT(KUSB, Kern::Printf(" > WARNING: iEndpoints[%d].iRxBuf != NULL", aRealEndpoint));

		return KErrGeneral;

		}

	ep->iRxBuf = aCallback.iBufferStart;

	ep->iReceived = 0;

	ep->iLength = aCallback.iLength;

	// For Bulk reads we start out with the assumption of 1 packet (see BulkReceive for why):

	ep->iPackets = IS_BULK_OUT_ENDPOINT(aRealEndpoint) ? 1 : 0;

	ep->iRequest = &aCallback;

	ep->iPacketIndex = aCallback.iPacketIndex;

	if (IS_BULK_OUT_ENDPOINT(aRealEndpoint))

		*ep->iPacketIndex = 0;								// a one-off optimization

	ep->iPacketSize = aCallback.iPacketSize;

	const TInt n = ArrayIdx2TemplateEp(aRealEndpoint);

	if (ep->iDisabled)

		{

		ep->iDisabled = EFalse;

		EnableEndpointInterrupt(n);

		}

	else if (ep->iNoBuffer)

		{

		__KTRACE_OPT(KUSB, Kern::Printf(" > There had been no Rx buffer available: reading Rx FIFO now"));

		ep->iNoBuffer = EFalse;

		if (IS_BULK_OUT_ENDPOINT(aRealEndpoint))

			{

			BulkReadRxFifo(n);

			}

		else if (IS_ISO_OUT_ENDPOINT(aRealEndpoint))

			{

			IsoReadRxFifo(n);

			}

		else

			{

			__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Endpoint not found"));

			}

		}

	return KErrNone;

	}

TInt TTemplateAsspUsbcc::SetupEndpointWrite(TInt aRealEndpoint, TUsbcRequestCallback& aCallback)

//

// Sets up a write request for an endpoint on behalf of the LDD.

//

	{

	__KTRACE_OPT(KUSB, Kern::Printf("TTemplateAsspUsbcc::SetupEndpointWrite(%d)", aRealEndpoint));

	if (!IS_IN_ENDPOINT(aRealEndpoint))

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: !IS_IN_ENDPOINT(%d)", aRealEndpoint));

		return KErrArgument;

		}

	TEndpoint* const ep = &iEndpoints[aRealEndpoint];

	if (ep->iTxBuf != NULL)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: iEndpoints[%d].iTxBuf != NULL", aRealEndpoint));

		return KErrGeneral;

		}

	ep->iTxBuf = aCallback.iBufferStart;