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

 // omap3530/omap3530_drivers/usbcc/omap3530_usbc.h

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

 //

 #ifndef __OMAP3530_USBC_H__

 #define __OMAP3530_USBC_H__

 #include <e32cmn.h>

 #include <drivers/usbc.h>

 #include <assp/omap3530_assp/omap3530_assp_priv.h>

 // This is the header file for the implementation of the USB driver PSL layer for an imaginary USB client

 // (device) controller.

 // For simplicity's sake we assume the following endpoint layout of the controller.

 // We have 5 endpoints in total - two Bulk endpoints (IN and OUT), two Isochronous endpoint (IN and OUT),

 // one Interrupt endpoint (IN), and of course endpoint zero (Ep0).

 //

 // This is the mapping of "Hardware Endpoint Numbers" to "Real Endpoints" (and thus is also

 // used as the array index for our local TTemplateAsspUsbcc::iEndpoints[]):

 //

 //	0 -	 0 (Ep0 OUT)

 //	0 -	 1 (Ep0 IN)

 //	1 -	 3 (Bulk  IN, Address 0x11, -> EpAddr2Idx(0x11) =  3)

 //	2 -	 4 (Bulk OUT, Address 0x02, -> EpAddr2Idx(0x02) =  4)

 //	3 -	 7 (Iso   IN, Address 0x13, -> EpAddr2Idx(0x13) =  7)

 //	4 -	 8 (Iso  OUT, Address 0x04, -> EpAddr2Idx(0x04) =  8)

 //	5 - 11 (Int   IN, Address 0x15, -> EpAddr2Idx(0x15) = 11)

 //

 // For the reason why this is so (or rather for the perhaps not so obvious system behind it),

 // see the comment at the beginning of \e32\drivers\usbcc\ps_usbc.cpp and also the structure

 // DeviceEndpoints[] at the top of pa_usbc.cpp.

 // The total number of endpoints in our local endpoint array:

 static const TInt KUsbTotalEndpoints = 16; //32; // Disabled due to limited FIFO space

 // The numbers used in the following macros are 'aRealEndpoint's (i.e. array indices):

 #define IS_VALID_ENDPOINT(x)	((x) > 0 && (x) < KUsbTotalEndpoints)

 #define IS_OUT_ENDPOINT(x)		IS_VALID_ENDPOINT(x) && ((x) == 0 || (x) == 2 || (x) == 4 || (x) == 6 || (x) == 8 || (x) == 10 || (x) == 12 || (x) == 14 || (x) == 16 || (x) == 18 || (x) == 20 || (x) == 22 ||(x) == 24 || (x) == 26 ||(x) == 28) 

 #define IS_IN_ENDPOINT(x)		IS_VALID_ENDPOINT(x) && ((x) == 1 || (x) == 3 || (x) == 5 || (x) == 7 || (x) == 9 || (x) == 11 || (x) == 13 || (x) == 15 || (x) == 17 || (x) == 19 || (x) == 21 || (x) == 23 ||(x) == 25 || (x) == 27 ||(x) == 29)

 #define IS_BULK_IN_ENDPOINT(x)	IS_VALID_ENDPOINT(x) && ((x) == 1 || (x) == 3 || (x) == 5 || (x) == 7 || (x) == 9 || (x) == 11 || (x) == 13 || (x) == 15 || (x) == 17 || (x) == 19 || (x) == 21 || (x) == 23 ||(x) == 25 || (x) == 27)

 #define IS_BULK_OUT_ENDPOINT(x)		IS_VALID_ENDPOINT(x) &&((x) == 2 || (x) == 4 || (x) == 6 || (x) == 8 || (x) == 10 || (x) == 12 || (x) == 14 || (x) == 16 || (x) == 18 || (x) == 20 || (x) == 22 ||(x) == 24 || (x) == 26 ||(x) == 28) 

 #define IS_BULK_ENDPOINT(x)		(IS_BULK_IN_ENDPOINT(x) || IS_BULK_OUT_ENDPOINT(x))

 #define IS_ISO_IN_ENDPOINT(x)	EFalse

 #define IS_ISO_OUT_ENDPOINT(x)	EFalse

 #define IS_ISO_ENDPOINT(x)		(IS_ISO_IN_ENDPOINT(x) || IS_ISO_OUT_ENDPOINT(x))

 #define IS_INT_IN_ENDPOINT(x)	IS_VALID_ENDPOINT(x) && ((x) == 29)

 // This takes as an index the TTemplateAsspUsbcc::iEndpoints index (== aRealEndpoint) 0..11

 // and returns the hardware endpoint number 0..5 (note that not all input indices are valid;

 // these will return -1):

 /*static const TInt TBeagleAsspEndpoints[KUsbTotalEndpoints] = 

 {0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30};*/

 static const TInt TBeagleAsspEndpoints[KUsbTotalEndpoints] = 

 {0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};

 // And here is a function to use the above array:

 static inline TInt ArrayIdx2TemplateEp(TInt aRealEndpoint)

 	{

 	if (IS_VALID_ENDPOINT(aRealEndpoint)) return TBeagleAsspEndpoints[aRealEndpoint];

 	else return -1;

 	}

 static inline TInt TemplateEp2ArrayIdx(TInt aRealEndpoint)

 	{

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

 		{

 		if(TBeagleAsspEndpoints[x]==aRealEndpoint)

 			return x;

 		}

 	return -1;

 	}

 // Access to clocks is reference counted

 static TInt iSICLKEnabled;

 // Endpoint max packet sizes

 static const TInt KEp0MaxPktSz = 64;						// Control

 static const TInt KIntMaxPktSz = 64;							// Interrupt

 static const TInt KBlkMaxPktSz = 512;						// Bulk

 static const TInt KIsoMaxPktSz = 256;						// Isochronous

 static const TInt KEp0MaxPktSzMask = KUsbEpSize64;			// Control

 static const TInt KIntMaxPktSzMask = KUsbEpSize64;			// Interrupt

 static const TInt KBlkMaxPktSzMask = /*KUsbEpSize64 | */KUsbEpSize512;			// Bulk

 static const TInt KIsoMaxPktSzMask = KUsbEpSize256;			// Isochronous

 // 1 ms (i.e. the shortest delay possible with the sort of timer used) seems to give

 // the best results, both for Bulk and Iso, and also (in the USBRFLCT test program)

 // both for loop tests as well as unidirectional transfers.

 static const TInt KRxTimerTimeout = 5;						// milliseconds

 // Used in descriptors

 static const TUint16 KUsbVendorId	= KUsbVendorId_Symbian;	// Symbian

 static const TUint16 KUsbProductId	= 0x0666;				// bogus...

 static const TUint16 KUsbDevRelease = 0x0100;				// bogus... (BCD!)

 static const TUint16 KUsbLangId		= 0x0409;				// English (US) Language ID

 // String descriptor default values

 static const wchar_t KStringManufacturer[] = L"Symbian Software Ltd.";

 static const wchar_t KStringProduct[]	   = L"BeagleBoard";

 static const wchar_t KStringSerialNo[]	   = L"0123456789";

 static const wchar_t KStringConfig[]	   = L"First and Last and Always";

 // We use our own Ep0 state enum:

 enum TEp0State

 	{

 	EP0_IDLE = 0,											// These identifiers don't conform to

 	EP0_OUT_DATA_PHASE = 1,									// Symbian's coding standard... ;)

 	EP0_IN_DATA_PHASE = 2,

 	EP0_END_XFER = 3,

 	};

 class DOmap3530Usbcc;

 // The lowest level endpoint abstraction

 struct TEndpoint

 	{

 	TEndpoint();

 	static void RxTimerCallback(TAny* aPtr);

 	// data

 	DOmap3530Usbcc* iController;						// pointer to controller object

 	union

 		{

 		TUint8* iRxBuf;										// where to store /

 		const TUint8* iTxBuf;								// from where to send

 		};

 	union

 		{

 		TInt iReceived;										// bytes already rx'ed /

 		TInt iTransmitted;									// bytes already tx'ed

 		};

 	TInt iLength;											// number of bytes to be transferred

 	TBool iZlpReqd;											// ZeroLengthPacketRequired

 	TBool iNoBuffer;										// no data buffer was available when it was needed

 	TBool iDisabled;										// dto but stronger

 	TInt iPackets;											// number of packets rx'ed or tx'ed

 	TInt iLastError;										//

 	TUsbcRequestCallback* iRequest;							//

 	NTimer iRxTimer;										//

 	TBool iRxTimerSet;										// true if iRxTimer is running

 	TBool iRxMoreDataRcvd;									// true if after setting timer data have arrived

 	TUsbcPacketArray* iPacketIndex;							// actually TUsbcPacketArray (*)[]

 	TUsbcPacketArray* iPacketSize;							// actually TUsbcPacketArray (*)[]

 	};

 // The hardware driver object proper

 class Omap3530BoardAssp;

 class MOmap3530UsbPhy;

 NONSHARABLE_CLASS( DOmap3530Usbcc ) : public DUsbClientController

 	{

 friend void TEndpoint::RxTimerCallback(TAny*);

 public:

 	enum TPHYMode

 		{

 		ENormal,

 		EPowerUp,

 		EPeripheralChirp,

 		EUART

 		};

 public:

 	DOmap3530Usbcc();

 	TInt Construct();

 	virtual ~DOmap3530Usbcc();

 	virtual void DumpRegisters();

 private:

 	virtual TInt SetDeviceAddress(TInt aAddress);

 	virtual TInt ConfigureEndpoint(TInt aRealEndpoint, const TUsbcEndpointInfo& aEndpointInfo);

 	virtual TInt DeConfigureEndpoint(TInt aRealEndpoint);

 	virtual TInt AllocateEndpointResource(TInt aRealEndpoint, TUsbcEndpointResource aResource);

 	virtual TInt DeAllocateEndpointResource(TInt aRealEndpoint, TUsbcEndpointResource aResource);

 	virtual TBool QueryEndpointResource(TInt aRealEndpoint, TUsbcEndpointResource aResource) const;

 	virtual TInt OpenDmaChannel(TInt aRealEndpoint);

 	virtual void CloseDmaChannel(TInt aRealEndpoint);

 	virtual TInt SetupEndpointRead(TInt aRealEndpoint, TUsbcRequestCallback& aCallback);

 	virtual TInt SetupEndpointWrite(TInt aRealEndpoint, TUsbcRequestCallback& aCallback);

 	virtual TInt CancelEndpointRead(TInt aRealEndpoint);

 	virtual TInt CancelEndpointWrite(TInt aRealEndpoint);

 	virtual TInt SetupEndpointZeroRead();

 	virtual TInt SetupEndpointZeroWrite(const TUint8* aBuffer, TInt aLength, TBool aZlpReqd = EFalse);

 	virtual TInt SendEp0ZeroByteStatusPacket();

 	virtual TInt StallEndpoint(TInt aRealEndpoint);

 	virtual TInt ClearStallEndpoint(TInt aRealEndpoint);

 	virtual TInt EndpointStallStatus(TInt aRealEndpoint) const;

 	virtual TInt EndpointErrorStatus(TInt aRealEndpoint) const;

 	virtual TInt ResetDataToggle(TInt aRealEndpoint);

 	virtual TInt SynchFrameNumber() const;

 	virtual void SetSynchFrameNumber(TInt aFrameNumber);

 	virtual TInt StartUdc();

 	virtual TInt StopUdc();

 	virtual TInt UdcConnect();

 	virtual TInt UdcDisconnect();

 	virtual TBool UsbConnectionStatus() const;

 	virtual TBool UsbPowerStatus() const;

 	virtual TBool DeviceSelfPowered() const;

 	virtual const TUsbcEndpointCaps* DeviceEndpointCaps() const;

 	virtual TInt DeviceTotalEndpoints() const;

 	virtual TBool SoftConnectCaps() const;

 	virtual TBool DeviceStateChangeCaps() const;

 	virtual void Suspend();

 	virtual void Resume();

 	virtual void Reset();

 	virtual TInt SignalRemoteWakeup();

 	virtual void Ep0ReadSetupPktProceed();

 	virtual void Ep0ReceiveProceed();

 	virtual TDfcQue* DfcQ(TInt aUnit);

 	virtual TBool CurrentlyUsingHighSpeed();

 private:

 	// general

 	void EnableEndpointInterrupt(TInt aEndpoint);

 	void DisableEndpointInterrupt(TInt aEndpoint);

 	void ClearEndpointInterrupt(TInt aEndpoint);

 	void InitialiseUdcRegisters();

 	void UdcEnable();

 	void UdcDisable();

 	TInt SetupUdcInterrupt();

 	void ReleaseUdcInterrupt();

 	void UdcInterruptService();

 	void EndpointIntService(TInt aEndpoint);

 	TInt ResetIntService();

 	void SuspendIntService();

 	void ResumeIntService();

 	void SofIntService();

 	static void UdcIsr(TAny* aPtr);

 	static TInt UsbClientConnectorCallback(TAny* aPtr);

 	// endpoint zero

 	void Ep0IntService();

 	void Ep0ReadSetupPkt();

 	void Ep0Receive();

 	void Ep0Transmit();

 	void Ep0EndXfer();

 	void Ep0Cancel();

 	void Ep0PrematureStatusOut();

 	void Ep0StatusIn();

 	void Ep0NextState(TEp0State aNextState);

 	// endpoint n with n != 0

 	void BulkTransmit(TInt aEndpoint);

 	void BulkReceive(TInt aEndpoint);

 	void BulkReadRxFifo(TInt aEndpoint);

 	void IsoTransmit(TInt aEndpoint);

 	void IsoReceive(TInt aEndpoint);

 	void IsoReadRxFifo(TInt aEndpoint);

 	void IntTransmit(TInt aEndpoint);

 	void RxComplete(TEndpoint* aEndpoint);

 	void StopRxTimer(TEndpoint* aEndpoint);

 private:

 	void EnableSICLK();

 	void DisableSICLK();

 	// Dfc functions

 	static void SuspendDfcFn(TAny *aPtr);

 	static void ResumeDfcFn(TAny *aPtr);

 	static void ResetDfcFn(TAny *aPtr);

 public:

 	TBool DeviceHighSpeedCaps() const;

 private:

 	// general

 	TBool iSoftwareConnectable;

 	TBool iCableDetectable;

 	TBool iCableConnected;

 	TBool iBusIsPowered;

 	TBool iInitialized;

 	TInt (*iUsbClientConnectorCallback)(TAny *);

 	Omap3530Assp* iAssp;

 	// endpoint zero

 	TBool iEp0Configured;

 	TEp0State iEp0State;

 	// endpoints n

 	TEndpoint iEndpoints[KUsbTotalEndpoints];				// for how this is indexed, see top of pa_usbc.cpp

 	// Dfc's for configuring the Tranceiver when we get a Suspend/Resume/Reset interrupt.

 	TDfcQue* iDfcQueue;

 	TDfc iSuspendDfc;

 	TDfc iResumeDfc;

 	TDfc iResetDfc;

 	MOmap3530UsbPhy*	iPhy;

 	TUint	iPrmClientId;

 	};

 class MOmap3530UsbPhy

 	{

 public:

 	IMPORT_C static MOmap3530UsbPhy* New();

 	virtual void StartPHY() = 0;

 	virtual void SetPHYMode( DOmap3530Usbcc::TPHYMode aMode ) = 0;

 	virtual void EnablePHY() = 0;

 	virtual void DisablePHY() = 0;

 	};

 #endif // __PA_USBC_H__