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

// e32\include\d32usbcsc.h

// User side class definitions for USB Device support.

// 

//

/**

 @file d32usbcsc.h

 @publishedPartner

 @released

*/

#ifndef __D32USBCSC_H__

#define __D32USBCSC_H__

#include <e32ver.h>

#include <usb.h>

#include <d32usbcshared.h>

/** This means that SetInterface was called after RealizeInterface had been called.

    RealizeInterface is meant to signal that all interfaces have been set.

*/

const TInt KErrUsbAlreadyRealized = -6813; //Changed from -6713 for future compatibility with the d32usbcshared.h file

const TInt KErrAlternateSettingChanged = -6814;

const TUint KChunkCellSize = 1; //1 32 bit integer

const TInt KEpDescPacketSizeOffset = 4;

/** The user side enpoint number of Endpoint Zero. */

const TInt KEp0Number = 0;

/* Used in TUsbcScHdrEndpointRecord to describe the endpoint type

*/

const TUint8 KUsbScHdrEpDirectionIn=1;

const TUint8 KUsbScHdrEpDirectionOut=2;

const TUint8 KUsbScHdrEpDirectionBiDir=3;

const TUint8 KUsbScHdrEpTypeControl = 0;

const TUint8 KUsbScHdrEpTypeIsochronous =1;

const TUint8 KUsbScHdrEpTypeBulk = 2;

const TUint8 KUsbScHdrEpTypeInterrupt = 3;

const TUint8 KUsbScHdrEpTypeUnknown = ~0;

/** Used in the the Shared Chunk Header, to represent an endpoint.

*/

class TUsbcScHdrEndpointRecord

	{

public:

	inline TUsbcScHdrEndpointRecord(TInt aBufferNo, TUint8 aType);

	inline TUint Direction() const;

	inline TUint Type() const;

public:

	TUint8 iBufferNo;

	TUint8 iType;

	TUint16 iReserved;

	};

// This is used to hold the geometry of the shared buffers

class TUsbcScBufferRecord

	{

	friend class DLddUsbcScChannel;

public:

	inline TUint Offset() const;

	inline TUint Size() const;

private:

	inline void Set(TUint aOffset, TUint aEndOffset);

	TUint iOffset;

	TUint iSize;

	};

struct SUsbcScBufferHeader

	{

	TInt iHead;		// Where the LDD will next write a transfer

	TInt iTail;		// Indicates the fist packet that user side is processing (anything prior is disposable)

	TInt iBilTail;  // This is not used by LDD at all, but just for the BIL's benifit.

	};

struct SUsbcScAlternateSetting

	{

	TUint16 iSetting;

	TUint16 iSequence;

	};

/** Endpoint pair information.  This can be used to control pairing of endpoint

for classes that require explicit pairing of endpoint, such as ADC.

This is currently not used.

*/

class TEndpointPairInfo

{

public:

	TEndpointPairInfo(TUint8 aType=0, TUint16 aPair=0, TUint8 aSpare=0);

public:

	TUint8 iType;

	TUint8 iSpare;

	TUint16 iPair;

}; 

/**

This is the buffer number reserved for use with endpoint zero with the  ReadDataNotify and WriteData methods.

*/

const TInt KUsbcScEndpointZero = -1;

/**

This flag is reserved in TUsbcscEndpointInfo::iFlags, to indicate that the client driver's client wishes reads to operate in a coupled fashion.

This behaviour is not currently supported.

*/

const TUint KUsbScCoupledRead = 0x1;

/**

This flag, used in parameter aFlag of WriteData, is used to indicate that a ZLP should be sent.

*/

const TUint KUsbcScWriteFlagsZlp = 0x0001;

// Bit fields used in iFlags of TUsbcScTransferHeader

const TUint KUsbcScShortPacket = 0x0001;

const TUint KUsbcScStateChange = 0x0004;

class TUsbcScTransferHeader

{

public:

#ifdef _DEBUG

	TUint iHashId;

	TUint iSequence;

#endif

	TUint iBytes;

	TUint iFlags;

	TUint iNext;

	TUint16 iAltSettingSeq;

	TInt16 iAltSetting;

	union

	{

		TUint  i[1]; // Extends

		TUint8 b[4]; // Extends

	} iData;

};

/** The desired endpoint capabilities used in RDevUsbcScClient::SetInterface().

This derived class has additional fields used in the shared chunk USB driver.

*/

class TUsbcScEndpointInfo: public TUsbcEndpointInfo

	{

public:

	TUsbcScEndpointInfo(TUint aType=KUsbEpTypeBulk, TUint aDir=KUsbEpDirOut, TInt aInterval=0, TInt aExtra=0,

												TUint aBufferSize=0, TUint aReadSize=0);

public:

	/** This indicates the requested size of the endpoint buffer and must be at

		least as large as iReadSize.

	*/

	TUint iBufferSize;

	/** This is the amount of data that the LDD reads from the bus before it sets

	    up another read and is normally intended to read many packets.

	*/

	TUint iReadSize;

	/** TEndpointPairInfo represents pairing information for isochronous endpoints.

		Should be zero in other cases.  If this specifies paired endpoints then

		iExtra (in the base class TUsbcEndpointInfo) also needs to be set to the

		class specific size for this endpoint descriptor (This is here only for future use).

	*/

	TEndpointPairInfo iPairing;

	/** The necessary alignment, in bytes, that needs to be applied to the transfer start points

	    of the data.  This is only observed on OUT endpoints.  Zero can be specified to indicate

		there are no class side requirements for alignment.   The alignment for OUT endpoints is

		which ever is greater of this field or the USB hardware requirements.

	*/

	TUint iAlignment;

	/** Flags to indicate how the endpoint should function. None currently defined,

	    but could be used to allow support for direct read.

	*/

	TUint iFlags;

	/** Reserved for future use. */

	TUint32 iReserved2[2];

	};

/** This must be filled in prior to a call to RDevUsbcClient::SetInterface().

*/

class TUsbcScInterfaceInfo

	{

public:

	TUsbcScInterfaceInfo(TInt aClass=0, TInt aSubClass=0, TInt aProtocol=0,

					   TDesC16* aString=NULL, TUint aTotalEndpoints=0);

public:

	/** The class, subclass and protocol that this interface supports. */

	TUsbcClassInfo iClass;

	/** The description string for the interface. Used to construct the interface string descriptor. */

	const TDesC16* iString;

	/** Total number of endpoints being requested (0-5). Endpoint 0 should not be included in this number. */

	TUint iTotalEndpointsUsed;

	/** Desired properties of the endpoints requested.

		Do NOT include endpoint 0.

		APIs use endpoint numbers that are offsets into this array.

	*/

	TUsbcScEndpointInfo iEndpointData[KMaxEndpointsPerClient];

	/** 32 flag bits used for specifying miscellaneous Interface features.

		Currently defined are:

		- KUsbcInterfaceInfo_NoEp0RequestsPlease = 0x00000001

	*/

	TUint32 iFeatureWord;

	};

/** Package buffer for a TUsbcInterfaceInfo object.

	@see TUsbcInterfaceInfo

*/

typedef TPckgBuf<TUsbcScInterfaceInfo> TUsbcScInterfaceInfoBuf;

struct TUsbcScChunkHdrOffs

	{

	TUint iBuffers;

	TUint iAltSettings;

	};

class TUsbcScChunkBuffersHeader  // Not instantiable

	{

	friend class DLddUsbcScChannel;

	friend class TRealizeInfo;

public:

	inline TUsbcScBufferRecord* Ep0Out() const;

	inline TUsbcScBufferRecord* Ep0In() const;

	inline TUsbcScBufferRecord* Buffers(TInt aBuffer) const;

	inline TInt NumberOfBuffers() const;

private:

	TUsbcScChunkBuffersHeader();

private:

	TInt iRecordSize;

	TInt  iNumOfBufs;

	TUint8 iBufferOffset[8]; // Extends

	};

struct TUsbcScChunkAltSettingHeader // Not instantiable

	{

	TInt iEpRecordSize;

	TInt iNumOfAltSettings;

	TUint iAltTableOffset[1]; // Extends

	};

class TEndpointBuffer;

/** The user side handle to the USB client driver.

*/

class RDevUsbcScClient : public RBusLogicalChannel

	{

public:

	/** @internalComponent */

	enum TVer

		{

		EMajorVersionNumber = 0,

		EMinorVersionNumber = 1,

		EBuildVersionNumber = KE32BuildVersionNumber

		};

// Bit pattern. s = Request/Control.  c = Cancel,  m = mode bits, B = Buffer number, R = request number.

//	scmm mmmm |  mmmm mmmm | mmBB BBBB |RRRR RRRR  

	enum TRequest

		{

		ERequestWriteData = 1,

		ERequestReadDataNotify = 2, 	

		ERequestAlternateDeviceStatusNotify = 3,

		ERequestReEnumerate = 4,

		ERequestEndpointStatusNotify = 5,

 		ERequestOtgFeaturesNotify = 6,

		ERequestMaxRequests, // 7

		ERequestCancel = 0x40000000,

		ERequestWriteDataCancel						= ERequestWriteData                   | ERequestCancel,

		ERequestReadDataNotifyCancel				= ERequestReadDataNotify              | ERequestCancel,

		ERequestAlternateDeviceStatusNotifyCancel 	= ERequestAlternateDeviceStatusNotify | ERequestCancel,

		ERequestReEnumerateCancel 					= ERequestReEnumerate                 | ERequestCancel,

		ERequestEndpointStatusNotifyCancel 			= ERequestEndpointStatusNotify        | ERequestCancel,

        ERequestOtgFeaturesNotifyCancel 			= ERequestOtgFeaturesNotify           | ERequestCancel

		};

	enum TControl

		{

		// Changing the order of these enums will break BC.

		EControlEndpointZeroRequestError,					// 00

		EControlEndpointCaps,

		EControlDeviceCaps,

		EControlGetAlternateSetting,

		EControlDeviceStatus,

		EControlEndpointStatus,

		EControlSetInterface,

		EControlReleaseInterface,

		EControlSendEp0StatusPacket,

		EControlHaltEndpoint,								// 09

		//

		EControlClearHaltEndpoint,							// 10

		EControlSetDeviceControl,

		EControlReleaseDeviceControl,

		EControlEndpointZeroMaxPacketSizes,

		EControlSetEndpointZeroMaxPacketSize,

		EControlGetDeviceDescriptor,

		EControlSetDeviceDescriptor,

		EControlGetDeviceDescriptorSize,

		EControlGetConfigurationDescriptor,

		EControlSetConfigurationDescriptor,					// 19

		//

		EControlGetConfigurationDescriptorSize,				// 20

		EControlGetInterfaceDescriptor,

		EControlSetInterfaceDescriptor,

		EControlGetInterfaceDescriptorSize,

		EControlGetEndpointDescriptor,

		EControlSetEndpointDescriptor,

		EControlGetEndpointDescriptorSize,

		EControlGetCSInterfaceDescriptor,

		EControlSetCSInterfaceDescriptor,

		EControlGetCSInterfaceDescriptorSize,				// 29

		//

		EControlGetCSEndpointDescriptor,					// 30

		EControlSetCSEndpointDescriptor,

		EControlGetCSEndpointDescriptorSize,

		EControlSignalRemoteWakeup,

		EControlGetStringDescriptorLangId,

		EControlSetStringDescriptorLangId,

		EControlGetManufacturerStringDescriptor,

		EControlSetManufacturerStringDescriptor,

		EControlRemoveManufacturerStringDescriptor,

		EControlGetProductStringDescriptor,					// 39

		//

		EControlSetProductStringDescriptor,					// 40

		EControlRemoveProductStringDescriptor,

		EControlGetSerialNumberStringDescriptor,

		EControlSetSerialNumberStringDescriptor,

		EControlRemoveSerialNumberStringDescriptor,

		EControlGetConfigurationStringDescriptor,

		EControlSetConfigurationStringDescriptor,

		EControlRemoveConfigurationStringDescriptor,

		EControlDeviceDisconnectFromHost,

		EControlDeviceConnectToHost,						// 49

		//

		EControlDevicePowerUpUdc,							// 50

		EControlDumpRegisters,

		EControlAllocateEndpointResource,

		EControlDeAllocateEndpointResource,

		EControlQueryEndpointResourceUse,

		EControlGetEndpointZeroMaxPacketSize,

		EControlGetDeviceQualifierDescriptor,

		EControlSetDeviceQualifierDescriptor,

		EControlGetOtherSpeedConfigurationDescriptor,

		EControlSetOtherSpeedConfigurationDescriptor,		// 59

		//

		EControlCurrentlyUsingHighSpeed,					// 60

		EControlSetStringDescriptor,

		EControlGetStringDescriptor,

		EControlRemoveStringDescriptor,

        EControlSetOtgDescriptor,

        EControlGetOtgDescriptor,

        EControlGetOtgFeatures, 

		EControlRealizeInterface,

		EControlStartNextInAlternateSetting	

		};

 // const static TUint KFieldIdPos     = 0;

	const static TUint KFieldIdMask    = 0xFF;

	const static TUint KFieldBuffPos   = 8;

	const static TUint KFieldBuffMask  = 0x3F;

	const static TUint KFieldFlagsPos  = 14;

	const static TUint KFieldFlagsMask = 0xFFFF;

public:

#ifndef __KERNEL_MODE__

	/** Opens a channel.

		@param aUnit This should be 0 (zero).

		@return KErrNone if successful.

	*/

	inline TInt Open(TInt aUnit);

	inline TVersion VersionRequired() const;

	/** Stalls ep0 to signal command fault to the host.

		@return KErrNone if successful.

	*/

	inline TInt EndpointZeroRequestError();

	/** Retrieves the capabilities of all the endpoints on the device.

		Suggested use is as follows:

		@code

		TUsbcEndpointData data[KUsbcMaxEndpoints];

		TPtr8 dataPtr(reinterpret_cast<TUint8*>(data), sizeof(data), sizeof(data));

		ret = usbPort.EndpointCaps(dataPtr);

		@endcode

		@param aEpCapsBuf A descriptor encapsulating an array of TUsbcEndpointData.

		@return KErrNone if successful.

	*/

	inline TInt EndpointCaps(TDes8& aEpCapsBuf);

	/** Retrieves the capabilities of the USB device.

		@see TUsbDeviceCaps

		@param aDevCapsBuf A TUsbDeviceCaps object.

		@return KErrNone if successful.

	*/

	inline TInt DeviceCaps(TUsbDeviceCaps& aDevCapsBuf);

	/** Copies the current alternate setting for this interface into aInterfaceNumber

		For USB Interfaces whose main interface is active, this will be 0 (zero).

		@param aInterfaceNumber Current alternate setting for this interface is copied into this.

		@return KErrNone if successful.

	*/

	inline TInt GetAlternateSetting(TInt& aInterfaceNumber);

	/** Copies the current device status into aDeviceStatus.

		@param aDeviceStatus Current device status is copied into this.

		@return KErrNone if successful

	*/

	inline TInt DeviceStatus(TUsbcDeviceState& aDeviceStatus);

	/** Copies the current endpoint status into aEndpointStatus.

		@param aEndpoint Endpoint number valid for the current alternate setting.

		@param aEndpointStatus The current endpoint status, might be stalled, not stalled or unknown.

		@return KErrNone if successful.

	*/

	inline TInt EndpointStatus(TInt aEndpoint, TEndpointState& aEndpointStatus);

	/** Requests that a zero length status packet be sent to the host in response

		to a class or vendor specific ep0 SETUP packet.

		@return KErrNone if successful.

	*/

	inline TInt SendEp0StatusPacket();

	/** Stalls endpoint aEndpoint, usually to indicate an error condition with a previous command.

		The host will normally send a SET_FEATURE command on ep0 to acknowledge and clear the stall.

		@return KErrNone if successful.

	*/

	inline TInt HaltEndpoint(TInt aEndpoint);

	/** Clears the stall condition on endpoint aEndpoint. This is inluded for symmetry and test purposes.

		@return KErrNone if successful.

	*/

	inline TInt ClearHaltEndpoint(TInt aEndpoint);

	/** Requests that device control be allocated to this channel.

		@return KErrNone if successful.

	*/

	inline TInt SetDeviceControl();

	/** Relinquishes device control previously allocated to this channel.

		@return KErrNone if successful.

	*/

	inline TInt ReleaseDeviceControl();

	/** Returns a bitmap of available ep0 maximum packet sizes.

		@return bitmap of available ep0 maximum packet sizes.

	*/

	inline TUint EndpointZeroMaxPacketSizes();

	/** Requests that a maximum packet size of aMaxPacketSize be set on ep0.

		@param aMaxPacketSize The maximum packet size.

		@return KErrNone if successful.

	*/

	inline TInt SetEndpointZeroMaxPacketSize(TInt aMaxPacketSize);

	/** Queries the current maximum packet size on ep0.

		@return The currently set maximum packet size on ep0.

	*/

	inline TInt GetEndpointZeroMaxPacketSize();

	/** Copies the current device descriptor into aDeviceDescriptor.

		@param aDeviceDescriptor Receives the current device descriptor.

		@return KErrNone if successful.

	*/

	inline TInt GetDeviceDescriptor(TDes8& aDeviceDescriptor);

	/** Sets the contents of aDeviceDescriptor to be the current device descriptor.

		@param aDeviceDescriptor Contains the device descriptor.

		@return KErrNone if successful.

	*/

	inline TInt SetDeviceDescriptor(const TDesC8& aDeviceDescriptor);

	/** Gets the size of the current device descriptor. This is unlikely to be anything other than 9.

		@param aSize Receives the size of the current device descriptor.

		@return KErrNone if successful.

	*/

	inline TInt GetDeviceDescriptorSize(TInt& aSize);

	/** Copies the current configuration descriptor into aConfigurationDescriptor.

		@param aConfigurationDescriptor Receives the current configuration descriptor.

		@return KErrNone if successful.

	*/

	inline TInt GetConfigurationDescriptor(TDes8& aConfigurationDescriptor);

	/** Sets the contents of aConfigurationDescriptor to be the current configuration descriptor.

		@param aConfigurationDescriptor Contains the configuration descriptor.

		@return KErrNone if successful.

	*/

	inline TInt SetConfigurationDescriptor(const TDesC8& aConfigurationDescriptor);

	/** Gets the size of the current configuration descriptor.

		@param aSize Receives the size of the current configuration descriptor.

		@return KErrNone if successful.

	*/

	inline TInt GetConfigurationDescriptorSize(TInt& aSize);

	/** Copies the interface descriptor into aInterfaceDescriptor for the interface with alternate

		setting aSettingNumber, 0 for the main interface.

		@param aSettingNumber Alternate setting number on the interface, 0 for the main interface.

		@param aInterfaceDescriptor Receives the interface descriptor.

		@return KErrNone if successful.

	*/

	inline TInt GetInterfaceDescriptor(TInt aSettingNumber, TDes8& aInterfaceDescriptor);

	/** Sets the interface descriptor contained in aInterfaceDescriptor for the interface with

		alternate setting aSettingNumber, 0 for the main interface, for transmission to the host

		during enumeration.

		@param aSettingNumber Alternate setting number on the interface, 0 for the main interface.

		@param aInterfaceDescriptor Contains the interface descriptor to be set.

		@return KErrNone if successful.

	*/

	inline TInt SetInterfaceDescriptor(TInt aSettingNumber, const TDesC8& aInterfaceDescriptor);

	/** Copies the size of the interface descriptor for the interface with alternate

		setting aSettingNumber, 0 for the main interface, into aSize.

		@param aSettingNumber The alternate setting.

		@param aSize receives the size of the interface descriptor.

		@return KErrNone if successful.

	*/

	inline TInt GetInterfaceDescriptorSize(TInt aSettingNumber, TInt& aSize);

	/** Copies the endpoint descriptor for logical endpoint number aEndpointNumber into aEndpointDescriptor

		for the interface with alternate setting aSettingNumber, 0 for the main interface.

		@param aSettingNumber Alternate setting number on the interface, 0 for the main interface.

		@param aEndpointNumber The endpoint number of the endpoint.

		@param aEndpointDescriptor Receives the endpoint descriptor.

		@return KErrNone if successful.

	*/

	inline TInt GetEndpointDescriptor(TInt aSettingNumber, TInt aEndpointNumber, TDes8& aEndpointDescriptor);

	/** Sets the endpoint descriptor for logical endpoint number aEndpointNumber contained in

		aEndpointDescriptor for the interface with alternate setting aSettingNumber, 0 for the main interface,

		for transmission to the host during enumeration.

		@param aSettingNumber Alternate setting number on the interface, 0 for the main interface.

		@param aEndpointNumber Valid endpoint number on this interface.

		@param aEndpointDescriptor Contains the endpoint descriptor to be set.

		@return KErrNone if successful.

	*/

	inline TInt SetEndpointDescriptor(TInt aSettingNumber, TInt aEndpointNumber,

									  const TDesC8& aEndpointDescriptor);

	/** Copies the size of the endpoint descriptor for logical endpoint number aEndpointNumber for the

		interface with alternate setting aSettingNumber, 0 for the main interface, into aSize.

		@param aSettingNumber Alternate setting number on the interface, 0 for the main interface.

		@param aEndpointNumber Valid endpoint number on this interface.

		@param aSize Receives the size of the endpoint descriptor.

		@return KErrNone if successful.

	*/

	inline TInt GetEndpointDescriptorSize(TInt aSettingNumber, TInt aEndpointNumber, TInt& aSize);

    /** Get OTG descriptor size

		@param aSize TInt Reference which contains OTG descriptor size on return.

    */

    inline void GetOtgDescriptorSize(TInt& aSize);

    /** Get OTG descriptor of USB on-the-go feature.

		@param aOtgDesc User-side buffer to store copy of descriptor.

		@return KErrNone if successful.

    */

    inline TInt GetOtgDescriptor(TDes8& aOtgDesc);

    /** Set OTG descriptor by user to enable/disable USB on-the-go feature.

		@param aOtgDesc Descriptor buffer containing OTG features.

		@return KErrNone if successful.

    */

    inline TInt SetOtgDescriptor(const TDesC8& aOtgDesc);

	/** Copies the current device_qualifier descriptor into aDescriptor.

		@param aDescriptor Receives the current device_qualifier descriptor.

		@return KErrNone if successful.

	*/

	inline TInt GetDeviceQualifierDescriptor(TDes8& aDescriptor);

	/** Sets the device_qualifier descriptor to the contents of aDescriptor.

		@param aDescriptor Contains the new device_qualifier descriptor.

		@return KErrNone if successful.

	*/

	inline TInt SetDeviceQualifierDescriptor(const TDesC8& aDescriptor);

	/** Copies the current other_speed_configuration descriptor into aDescriptor.

		@param aDescriptor Receives the current other_speed_configuration descriptor.

		@return KErrNone if successful.

	*/

	inline TInt GetOtherSpeedConfigurationDescriptor(TDes8& aDescriptor);

	/** Sets the other_speed_configuration descriptor to the contents of aDescriptor.

		@param aDescriptor Contains the new other_speed_configuration descriptor.

		@return KErrNone if successful.

	*/

	inline TInt SetOtherSpeedConfigurationDescriptor(const TDesC8& aDescriptor);

	/** Copies the class specific interface descriptor block into aInterfaceDescriptor for the interface

		with alternate setting aSettingNumber, 0 for the main interface.

		@param aSettingNumber Alternate setting number on the interface, 0 for the main interface.

		@param aInterfaceDescriptor Contains the interface descriptor to be set.

		@return KErrNone if successful.

	*/

	inline TInt GetCSInterfaceDescriptorBlock(TInt aSettingNumber, TDes8& aInterfaceDescriptor);

	/** aSettingNumber is the alternate interface setting, 0 for the main interface, that the descriptor block

		aDes should be attached to. aDes is a block of data containing at least one class specific descriptor

		for transmission during enumeration after the class interface descriptor (or alternate interface

		descriptor) has been sent, but before the endpoint descriptors belonging to this interface are sent.

		aDes may contain as many descriptors as are necessary or only one. SetCSInterfaceDescriptorBlock()

		should be called at any time after SetInterface() has been called to establish a main interface or an

		alternate interface. More than one call may be made - the data blocks will be concatenated prior to

		sending. No checking or validation of the contents of aDes will be made and it is the caller's

		responsibility to ensure that the data supplied is correct and appropriate to the interface identified

		by aSettingNumber.

		@param aSettingNumber Alternate setting number on the interface, 0 for the main interface.

		@param aInterfaceDescriptor Contains the interface descriptor to be set.

		@return KErrNone if successful.

	*/

	inline TInt SetCSInterfaceDescriptorBlock(TInt aSettingNumber, const TDesC8& aInterfaceDescriptor);

	/** Copies the size of the class specific interface descriptor block for the interface with alternate

		setting aSettingNumber, 0 for the main interface, into aSize.

		@param aSettingNumber The alternate setting number.

		@param aSize receives the size of the interface descriptor.

		@return KErrNone if successful.

	*/

	inline TInt GetCSInterfaceDescriptorBlockSize(TInt aSettingNumber, TInt& aSize);

	/** Copies the class specific endpoint descriptor for logical endpoint number aEndpointNumber

		into aEndpointDescriptor for the interface with alternate setting aSettingNumber, 0 for the main

		interface.

		@param aSettingNumber Alternate setting number on the interface, 0 for the main interface.

		@param aEndpointNumber Valid endpoint number on this interface.

		@param aEndpointDescriptor Receives the endpoint descriptor.

		@return KErrNone if successful.

	*/

	inline TInt GetCSEndpointDescriptorBlock(TInt aSettingNumber, TInt aEndpointNumber,

											 TDes8& aEndpointDescriptor);

	/** Sets the class specific endpoint descriptor for logical endpoint number aEndpointNumber contained in

		aEndpointDescriptor for the interface with alternate setting aSettingNumber, 0 for the main interface,

		for transmission to the host during enumeration.

		@param aSettingNumber Alternate setting number on the interface, 0 for the main interface.

		@param aEndpointNumber Valid endpoint number on this interface.

		@param aEndpointDescriptor Contains the endpoint descriptor to be set.

		@return KErrNone if successful.

	*/

	inline TInt SetCSEndpointDescriptorBlock(TInt aSettingNumber, TInt aEndpointNumber,

											 const TDesC8& aEndpointDescriptor);

	/** Copies the size of the class specific endpoint descriptor block for logical endpoint number

		aEndpointNumber for the interface with alternate setting aSettingNumber, 0 for the main interface,

		into aSize.

		@param aSettingNumber Alternate setting number on the interface, 0 for the main interface.

		@param aEndpointNumber Valid endpoint number on this interface.

		@param aSize On return, contains the size of the class specific endpoint descriptor block.

		@return KErrNone if successful.

	*/

	inline TInt GetCSEndpointDescriptorBlockSize(TInt aSettingNumber, TInt aEndpointNumber, TInt& aSize);

	/** Generates a Remote Wakeup bus condition.

		The capability of the device to generate Remote Wakeup signalling is enquired in

		RDevUsbcClient::DeviceCaps.

		@return KErrNone if this signalling is possible and the signal has been generated.

	*/

	inline TInt SignalRemoteWakeup();

	/** Simulates a physical removal of the USB cable by disabling the D+/- pull-ups.The iConnect member of

		TUsbDeviceCapsV01, returned by RDevUsbcClient::DeviceCaps(), indicates whether this functionality is

		supported.

		@return KErrNone if successful.

	*/

	inline TInt DeviceDisconnectFromHost();

	/** Simulates a physical insertion of the USB cable by enabling the D+/- pull-ups.The iConnect member

		of TUsbDeviceCapsV01, returned by RDevUsbcClient::DeviceCaps(),  indicates whether this functionality

		is supported.

		@return KErrNone if successful.

	*/

	inline TInt DeviceConnectToHost();

	/** Powers up the UDC and connects it to the bus if one or more interfaces exist.

		@return KErrNone if UDC successfully powered up, KErrNotReady if no

		interfaces have been registered yet, KErrHardwareNotAvailable if UDC

		couldn't be activated.

	*/

	inline TInt PowerUpUdc();

	/** Enquires about the current operating speed of the UDC.

		@return ETrue if the UDC is currently operating at High speed, EFalse otherwise.

	*/

	inline TBool CurrentlyUsingHighSpeed();

	/** Allocates the use of aResource to aEndpoint. It will be used from when the current bus transfer	has been

		completed.

		@param aResource is typically some rationed hardware resource or possibly specifies a type of endpoint

		behaviour. aResource is not a bitmap and TEndpointResource values should not be combined.

		@param aEndpoint The endpoint number to which the resource is to be allocated.

		@return KErrNone if successful, KErrInUse if the resource is already consumed and cannot be allocated,

		KErrNotSupported if the endpoint does not support the resource requested.

		@publishedPartner @deprecated

	*/

	inline TInt AllocateEndpointResource(TInt aEndpoint, TUsbcEndpointResource aResource);

	/** Deallocates the use of aResource aEndpoint or ends a specified endpoint behaviour.

		@param aResource is typically some rationed hardware resource or possibly specifies a type of endpoint

		behaviour. aResource is not a bitmap and TEndpointResource values should not be combined.

		@param aEndpoint The endpoint number from which the resource is to be removed.

		@return KErrNone if the resource has been successfully deallocated, KErrNotSupported if the endpoint

		does not support the resource requested.

		@publishedPartner @deprecated

	*/

	inline TInt DeAllocateEndpointResource(TInt aEndpoint, TUsbcEndpointResource aResource);

	/** Queries endpoint resource use.

		@param aResource is typically some rationed hardware resource or possibly specifies a type of endpoint

		behaviour. aResource is not a bitmap and TEndpointResource values should not be combined.

		@param aEndpoint The endpoint number at which the resource is to be queried.

		@return ETrue is the specified resource is in use at the endpoint and EFalse if not.

	*/

	inline TBool QueryEndpointResourceUse(TInt aEndpoint, TUsbcEndpointResource aResource);

	/** Request (i.e. claim for this channel) up to five endpoints and set the class type for this USB

		interface. 'aInterfaceData' is a package buffer which describes the interface and all the endpoints

		being requested by the driver for this interface.

		@param aInterfaceNumber Distinguishes between alternate interfaces. If these are not be used then this

		should always be zero. If this parameter is used, then its value must be one more than that of the

		proceeding alternate interface.

		@param aInterfaceData A package buffer which describes the interface and all the endpoints being

		requested by the driver for this interface.

		@return KErrInUse if any of the endpoints being requested have already been claimed by another channel.

		KErrNotSupported if an endpoint with all of the specified properties is not supported on this

		platform. KErrNoMemory if insufficient memory is available to complete the operation.

	*/

	inline TInt SetInterface(TInt aInterfaceNumber, TUsbcScInterfaceInfoBuf& aInterfaceData);

	/**

		This method should be called after SetInterface has been called for all possible alternative settings.

		Calling this invalidates further calls to SetInterface. On success, a chunk handle is created and

		passed back though aChunk.   This is needed for the user side to access the shared chunk where the

		data is stored.  Note that if you are using the BIL (described later), then FinalizeInterface (...)

		should be used instead, which will call this method.

		@return KErrNone on successful completion, or one of the system wide error codes.

	*/

	inline TInt RealizeInterface(RChunk& aChunk);

	/** Release an interface previously claimed by this channel. Alternate interfaces need to be released

		in strict descending order, starting with the last (i.e. highest numbered) one.

		It is not necessary to release an interface that wasn't successfully requested.

		@param aInterfaceNumber Specifies the alternate setting number 'aInterfaceNum' of the interface to be

		released.

		@return KErrNone if successful. KErrArgument if the alternate setting doesn't exist or is released out

		of order.

	*/

	inline TInt ReleaseInterface(TInt aInterfaceNumber);

	/** Copies the current string descriptor language ID (LANGID) code into the aLangId argument. Even though

		the USB spec allows for the existence of a whole array of LANGID codes, we only support one.

		@param aLangId Receives the LANGID code.

		@return KErrNone if successful, KErrArgument if problem with argument (memory cannot be written to, etc.).

	*/

	inline TInt GetStringDescriptorLangId(TUint16& aLangId);

	/** Sets the string descriptor language ID (LANGID). Even though the USB spec allows for the existence of

		a whole array of LANGID codes, we only support one.

		@param aLangId The LANGID code to be set.

		@return KErrNone if successful.

	*/

	inline TInt SetStringDescriptorLangId(TUint16 aLangId);

	/** Copies the string descriptor identified by the iManufacturer index field of the Standard Device

		Descriptor into the aString argument.

		@param aString Receives manufacturer string.

		@return KErrNone if successful, KErrArgument if MaxLength of aString is too small to hold the entire

		descriptor, KErrNotFound if the string descriptor couldn't be found.

	*/

	inline TInt GetManufacturerStringDescriptor(TDes16& aString);

	/** Sets the string descriptor identified by the iManufacturer index field of the Standard Device

		Descriptor to the aString argument.

		@param aString Contains the new manufacturer string descriptor.

		@return KErrNone if successful, KErrNoMemory if no memory is available to store the new string from

		aString (in which case the old string descriptor will be preserved).

	*/

	inline TInt SetManufacturerStringDescriptor(const TDesC16& aString);

	/** Removes (deletes) the string descriptor identified by the iManufacturer index field of the Standard

		Device Descriptor and sets that field to zero.

		@return KErrNone if successful, KErrNotFound if the string descriptor couldn't be found.

	*/

	inline TInt RemoveManufacturerStringDescriptor();

	/** Retrieves the string descriptor identified by the iProduct index field of the Standard Device

		Descriptor into the aString argument.

		@param aString Receives product string.

		@return KErrNone if successful, KErrArgument if MaxLength of aString is too small to hold the entire

		descriptor, KErrNotFound if the string descriptor couldn't be found.

	*/

	inline TInt GetProductStringDescriptor(TDes16& aString);

	/** Sets the string descriptor identified by the iProduct index field of the Standard Device Descriptor to

		the aString argument.

		@param aString Contains the new product string descriptor.

		@return KErrNone if successful, KErrNoMemory if no memory is available to store the new string from

		aString (in which case the old string descriptor will be preserved).

	*/

	inline TInt SetProductStringDescriptor(const TDesC16& aString);

	/** Removes (deletes) the string descriptor identified by the iProduct index field of the Standard Device

		Descriptor and sets that field to zero.

		@return KErrNone if successful, KErrNotFound if the string descriptor couldn't be found.

	*/

	inline TInt RemoveProductStringDescriptor();

	/** Retrieves the string descriptor identified by the iSerialNumber index field of the Standard Device

		Descriptor into the aString argument.

		@param aString Receives product string.

		@return KErrNone if successful, KErrArgument if MaxLength of aString is too small to hold the entire

		descriptor, KErrNotFound if the string descriptor couldn't be found.

	*/

	inline TInt GetSerialNumberStringDescriptor(TDes16& aString);

	/** Sets the string descriptor identified by the iSerialNumber index field of the Standard Device

		Descriptor to the aString argument.

		@param aString Contains the new serial number string descriptor.

		@return KErrNone if successful, KErrNoMemory if no memory is available to store the new string from

		aString (in which case the old string descriptor will be preserved).

	*/

	inline TInt SetSerialNumberStringDescriptor(const TDesC16& aString);

	/** Removes (deletes) the string descriptor identified by the iSerialNumber index field of the Standard

		Device Descriptor and sets that field to zero.

		@return KErrNone if successful, KErrNotFound if the string descriptor couldn't be found.

	*/

	inline TInt RemoveSerialNumberStringDescriptor();

	/** Retrieves the string descriptor identified by the iConfiguration index field of the (first) Standard

		Configuration Descriptor into the aString argument.

		@param aString Receives configuration string.

		@return KErrNone if successful, KErrArgument if MaxLength of aString is too small to hold the entire

		descriptor, KErrNotFound if the string descriptor couldn't be found.

	*/

	inline TInt GetConfigurationStringDescriptor(TDes16& aString);

	/** Sets the string descriptor identified by the iConfiguration index field of the Standard Configuration

		Descriptor to the aString argument.