// Copyright (c) 2002-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/drivers/usbcdesc.h
// USB descriptors and their management.
// 
//

/**
 @file usbcdesc.h
 @internalTechnology
*/

#ifndef __USBCDESC_H__
#define __USBCDESC_H__

#include <kernel/kernel.h>


// Hard-wired positions of some descriptors in iDescriptors array (whether present or not):
static const TInt KDescPosition_Device           = 0;
static const TInt KDescPosition_DeviceQualifier  = 1;
static const TInt KDescPosition_OtherSpeedConfig = 2;
static const TInt KDescPosition_Config           = 3;
static const TInt KDescPosition_Otg              = 4;
static const TInt KDescPosition_FirstAvailable   = 5;

// Hard-wired positions of string descriptors in iStrings array (whether present or not):
static const TInt KStringPosition_Langid           = 0;
static const TInt KStringPosition_Manufact         = 1;
static const TInt KStringPosition_Product          = 2;
static const TInt KStringPosition_Serial           = 3;
static const TInt KStringPosition_Config           = 4;
static const TInt KStringPosition_OtherSpeedConfig = 5;
static const TInt KStringPosition_FirstAvailable   = 6;


NONSHARABLE_CLASS(TUsbcDescriptorBase)
    {
public:
    virtual ~TUsbcDescriptorBase();
    void SetByte(TInt aPosition, TUint8 aValue);
    void SetWord(TInt aPosition, TUint16 aValue);
    TUint8 Byte(TInt aPosition) const;
    TUint16 Word(TInt aPosition) const;
    void GetDescriptorData(TDes8& aBuffer) const;
    TInt GetDescriptorData(TUint8* aBuffer) const;
    TInt GetDescriptorData(TUint8* aBuffer, TUint aMaxSize) const;
    const TDes8& DescriptorData() const;
    TDes8& DescriptorData();
    TUint Size() const;
    TUint8 Type() const;
    virtual void UpdateFs();
    virtual void UpdateHs();
protected:
    TUsbcDescriptorBase();
    void SetBufferPointer(const TDesC8& aDes);
private:
#ifdef USB_SUPPORTS_SET_DESCRIPTOR_REQUEST
    TUint8 iIndex;                                            // only needed for SET_DESCRIPTOR
#endif
    TPtr8 iBufPtr;
    };


NONSHARABLE_CLASS(TUsbcDeviceDescriptor) : public TUsbcDescriptorBase
    {
public:
    /** aMaxPacketSize0 should be the Ep0 max packet size for FS operation (as the HS size
        is fixed and known).
    */
    static TUsbcDeviceDescriptor* New(TUint8 aDeviceClass, TUint8 aDeviceSubClass,
                                      TUint8 aDeviceProtocol, TUint8 aMaxPacketSize0,
                                      TUint16 aVendorId, TUint16 aProductId,
                                      TUint16 aDeviceRelease, TUint8 aNumConfigurations);
    virtual void UpdateFs();
    virtual void UpdateHs();
private:
    TUsbcDeviceDescriptor();
    TInt Construct(TUint8 aDeviceClass, TUint8 aDeviceSubClass, TUint8 aDeviceProtocol,
                   TUint8 aMaxPacketSize0, TUint16 aVendorId, TUint16 aProductId,
                   TUint16 aDeviceRelease, TUint8 aNumConfigurations);
    TBuf8<KUsbDescSize_Device> iBuf;
    TUint8 iEp0Size_Fs;                                        // holds Ep0 size for FS (could be < 64)
    };


NONSHARABLE_CLASS(TUsbcDeviceQualifierDescriptor) : public TUsbcDescriptorBase
    {
public:
    /** aMaxPacketSize0 should be the Ep0 max packet size for FS operation (as the HS size
        is fixed and known).
    */
    static TUsbcDeviceQualifierDescriptor* New(TUint8 aDeviceClass, TUint8 aDeviceSubClass,
                                               TUint8 aDeviceProtocol, TUint8 aMaxPacketSize0,
                                               TUint8 aNumConfigurations, TUint8 aReserved=0);
    virtual void UpdateFs();
    virtual void UpdateHs();
private:
    TUsbcDeviceQualifierDescriptor();
    TInt Construct(TUint8 aDeviceClass, TUint8 aDeviceSubClass, TUint8 aDeviceProtocol,
                   TUint8 aMaxPacketSize0, TUint8 aNumConfigurations, TUint8 aReserved);
    TBuf8<KUsbDescSize_DeviceQualifier> iBuf;
    TUint8 iEp0Size_Fs;                                        // holds Ep0 size for FS (could be < 64)
    };


NONSHARABLE_CLASS(TUsbcConfigDescriptor) : public TUsbcDescriptorBase
    {
public:
    /** aMaxPower should be given here in milliamps (not mA/2). */
    static TUsbcConfigDescriptor* New(TUint8 aConfigurationValue, TBool aSelfPowered, TBool aRemoteWakeup,
                                      TUint16 aMaxPower);
private:
    TUsbcConfigDescriptor();
    TInt Construct(TUint8 aConfigurationValue, TBool aSelfPowered, TBool aRemoteWakeup, TUint16 aMaxPower);
    TBuf8<KUsbDescSize_Config> iBuf;
    };


// The Other_Speed_Configuration descriptor has same size and layout as the
// standard Configuration descriptor, therefore we don't need a new definition.
typedef TUsbcConfigDescriptor TUsbcOtherSpeedConfigDescriptor;


NONSHARABLE_CLASS(TUsbcInterfaceDescriptor) : public TUsbcDescriptorBase
    {
public:
    static TUsbcInterfaceDescriptor* New(TUint8 aInterfaceNumber, TUint8 aAlternateSetting, TInt NumEndpoints,
                                         const TUsbcClassInfo& aClassInfo);
private:
    TUsbcInterfaceDescriptor();
    TInt Construct(TUint8 aInterfaceNumber, TUint8 aAlternateSetting, TInt aNumEndpoints,
                   const TUsbcClassInfo& aClassInfo);
    TBuf8<KUsbDescSize_Interface> iBuf;
    };


NONSHARABLE_CLASS(TUsbcEndpointDescriptorBase) : public TUsbcDescriptorBase
    {
public:
    virtual void UpdateFs();
    virtual void UpdateHs();
protected:
    TInt Construct(const TUsbcEndpointInfo& aEpInfo);
    TUsbcEndpointDescriptorBase();
protected:
    /** Stores the endpoint size to be used for FS. */
    TInt iEpSize_Fs;
    /** Stores the endpoint size to be used for HS. */
    TInt iEpSize_Hs;
    /** Stores the endpoint polling interval to be used for FS. */
    TInt iInterval_Fs;
    /** Stores the endpoint polling interval to be used for HS. */
    TInt iInterval_Hs;
    };


NONSHARABLE_CLASS(TUsbcEndpointDescriptor) : public TUsbcEndpointDescriptorBase
    {
public:
    static TUsbcEndpointDescriptor* New(TUint8 aEndpointAddress, const TUsbcEndpointInfo& aEpInfo);
private:
    TUsbcEndpointDescriptor();
    TInt Construct(TUint8 aEndpointAddress, const TUsbcEndpointInfo& aEpInfo);
    TBuf8<KUsbDescSize_Endpoint> iBuf;
    };


class TUsbcAudioEndpointDescriptor : public TUsbcEndpointDescriptorBase
    {
public:
    static TUsbcAudioEndpointDescriptor* New(TUint8 aEndpointAddress, const TUsbcEndpointInfo& aEpInfo);
private:
    TUsbcAudioEndpointDescriptor();
    TInt Construct(TUint8 aEndpointAddress, const TUsbcEndpointInfo& aEpInfo);
    TBuf8<KUsbDescSize_AudioEndpoint> iBuf;
    };


NONSHARABLE_CLASS(TUsbcOtgDescriptor) : public TUsbcDescriptorBase
    {
public:
    static TUsbcOtgDescriptor* New(TBool aHnpSupport, TBool aSrpSupport);
private:
    TUsbcOtgDescriptor();
    TInt Construct(TBool aHnpSupport, TBool aSrpSupport);
    TBuf8<KUsbDescSize_Otg> iBuf;
    };


NONSHARABLE_CLASS(TUsbcClassSpecificDescriptor) : public TUsbcDescriptorBase
    {
public:
    virtual ~TUsbcClassSpecificDescriptor();
    static TUsbcClassSpecificDescriptor* New(TUint8 aType, TInt aSize);
private:
    TUsbcClassSpecificDescriptor();
    TInt Construct(TUint8 aType, TInt aSize);
    HBuf8* iBuf;
    };


NONSHARABLE_CLASS(TUsbcStringDescriptorBase)
    {
public:
    virtual ~TUsbcStringDescriptorBase();
    TUint16 Word(TInt aPosition) const;
    void SetWord(TInt aPosition, TUint16 aValue);
    TInt GetDescriptorData(TUint8* aBuffer) const;
    TInt GetDescriptorData(TUint8* aBuffer, TUint aMaxSize) const;
    const TDes8& StringData() const;
    TDes8& StringData();
    TUint Size() const;
    void SetBufferPointer(const TDesC8& aDes);
protected:
    TUsbcStringDescriptorBase();
    TBuf8<2> iSBuf;
    TPtr8 iBufPtr;
private:
//    TUint8 iIndex;                                            // not needed in DescriptorPool: position == index
    };


NONSHARABLE_CLASS(TUsbcStringDescriptor) : public TUsbcStringDescriptorBase
    {
public:
    virtual ~TUsbcStringDescriptor();
    static TUsbcStringDescriptor* New(const TDesC8& aString);
private:
    TUsbcStringDescriptor();
    TInt Construct(const TDesC8& aString);
    HBuf8* iBuf;
    };


// Currently we support only one language, and thus there's no need to provide
// a LangId string descriptor with more than one array element.
NONSHARABLE_CLASS(TUsbcLangIdDescriptor) : public TUsbcStringDescriptorBase
    {
public:
    virtual ~TUsbcLangIdDescriptor();
    static TUsbcLangIdDescriptor* New(TUint16 aLangId);
private:
    TUsbcLangIdDescriptor();
    TInt Construct(TUint16 aLangId);
    TBuf8<2> iBuf;
    };


class TUsbcDescriptorPool
    {
public:
    TUsbcDescriptorPool(TUint8* aEp0_TxBuf);
    ~TUsbcDescriptorPool();
    TInt Init(TUsbcDeviceDescriptor* aDeviceDesc, TUsbcConfigDescriptor* aConfigDesc,
              TUsbcLangIdDescriptor* aLangId, TUsbcStringDescriptor* aManufacturer,
              TUsbcStringDescriptor* aProduct, TUsbcStringDescriptor* aSerialNum,
              TUsbcStringDescriptor* aConfig, TUsbcOtgDescriptor* aOtgDesc);
    TInt InitHs();
    TInt UpdateDescriptorsFs();
    TInt UpdateDescriptorsHs();

    // Descriptors
    TInt FindDescriptor(TUint8 aType, TUint8 aIndex, TUint16 aLangid, TInt& aSize) const;
    void InsertDescriptor(TUsbcDescriptorBase* aDesc);
    void DeleteIfcDescriptor(TInt aNumber, TInt aSetting=0);
    // The TC in many of the following functions stands for 'ThreadCopy' because that's what happens there.
    TInt GetDeviceDescriptorTC(DThread* aThread, TDes8& aBuffer) const;
    TInt SetDeviceDescriptorTC(DThread* aThread, const TDes8& aBuffer);
    TInt GetConfigurationDescriptorTC(DThread* aThread, TDes8& aBuffer) const;
    TInt SetConfigurationDescriptorTC(DThread* aThread, const TDes8& aBuffer);
    TInt GetOtgDescriptorTC(DThread* aThread, TDes8& aBuffer) const;
    TInt SetOtgDescriptor(const TDesC8& aBuffer);
    TInt GetInterfaceDescriptorTC(DThread* aThread, TDes8& aBuffer, TInt aInterface, TInt aSetting) const;
    TInt SetInterfaceDescriptor(const TDes8& aBuffer, TInt aInterface, TInt aSetting);
    TInt GetEndpointDescriptorTC(DThread* aThread, TDes8& aBuffer, TInt aInterface, TInt aSetting,
                                 TUint8 aEndpointAddress) const;
    TInt SetEndpointDescriptorTC(DThread* aThread, const TDes8& aBuffer, TInt aInterface, TInt aSetting,
                                 TUint8 aEndpointAddress);
    TInt GetEndpointDescriptorSize(TInt aInterface, TInt aSetting, TUint8 aEndpointAddress, TInt& aSize) const;
    TInt GetDeviceQualifierDescriptorTC(DThread* aThread, TDes8& aBuffer) const;
    TInt SetDeviceQualifierDescriptorTC(DThread* aThread, const TDes8& aBuffer);
    TInt GetOtherSpeedConfigurationDescriptorTC(DThread* aThread, TDes8& aBuffer) const;
    TInt SetOtherSpeedConfigurationDescriptorTC(DThread* aThread, const TDes8& aBuffer);
    TInt GetCSInterfaceDescriptorTC(DThread* aThread, TDes8& aBuffer, TInt aInterface, TInt aSetting) const;
    TInt SetCSInterfaceDescriptorTC(DThread* aThread, const TDes8& aBuffer, TInt aInterface, TInt aSetting,
                                    TInt aSize);
    TInt GetCSInterfaceDescriptorSize(TInt aInterface, TInt aSetting, TInt& aSize) const;
    TInt GetCSEndpointDescriptorTC(DThread* aThread, TDes8& aBuffer, TInt aInterface, TInt aSetting,
                                   TUint8 aEndpointAddress) const;
    TInt SetCSEndpointDescriptorTC(DThread* aThread, const TDes8& aBuffer, TInt aInterface, TInt aSetting,
                                   TUint8 aEndpointAddress, TInt aSize);
    TInt GetCSEndpointDescriptorSize(TInt aInterface, TInt aSetting, TUint8 aEndpointAddress, TInt& aSize) const;

    // String descriptors
    void SetIfcStringDescriptor(TUsbcStringDescriptor* aDesc, TInt aNumber, TInt aSetting=0);
    TInt GetStringDescriptorLangIdTC(DThread* aThread, TDes8& aLangId) const;
    TInt SetStringDescriptorLangId(TUint16 aLangId);
    TInt GetManufacturerStringDescriptorTC(DThread* aThread, TDes8& aString) const;
    TInt SetManufacturerStringDescriptorTC(DThread* aThread, const TDes8& aString);
    TInt RemoveManufacturerStringDescriptor();
    TInt GetProductStringDescriptorTC(DThread* aThread, TDes8& aString) const;
    TInt SetProductStringDescriptorTC(DThread* aThread, const TDes8& aString);
    TInt RemoveProductStringDescriptor();
    TInt GetSerialNumberStringDescriptorTC(DThread* aThread, TDes8& aString) const;
    TInt SetSerialNumberStringDescriptorTC(DThread* aThread, const TDes8& aString);
    TInt RemoveSerialNumberStringDescriptor();
    TInt GetConfigurationStringDescriptorTC(DThread* aThread, TDes8& aString) const;
    TInt SetConfigurationStringDescriptorTC(DThread* aThread, const TDes8& aString);
    TInt RemoveConfigurationStringDescriptor();
    TInt GetStringDescriptorTC(DThread* aThread, TInt aIndex, TDes8& aString) const;
    TInt SetStringDescriptorTC(DThread* aThread, TInt aIndex, const TDes8& aString);
    TInt RemoveStringDescriptor(TInt aIndex);

private:
    // Descriptors
    void InsertIfcDesc(TUsbcDescriptorBase* aDesc);
    void InsertEpDesc(TUsbcDescriptorBase* aDesc);
    TInt FindIfcDescriptor(TInt aIfcNumber, TInt aIfcSetting) const;
    TInt FindEpDescriptor(TInt aIfcNumber, TInt aIfcSetting, TUint8 aEpAddress) const;
    void DeleteDescriptors(TInt aIndex, TInt aCount = 1);
    void UpdateConfigDescriptorLength(TInt aLength);
    void UpdateConfigDescriptorNumIfcs(TInt aNumber);
    void UpdateIfcNumbers(TInt aNumber);
    TInt GetDeviceDescriptor(TInt aIndex) const;
    TInt GetConfigurationDescriptor(TInt aIndex) const;
    TInt GetOtgDescriptor() const;

    // String descriptors
    TInt GetStringDescriptor(TInt aIndex) const;
    TInt GetDeviceStringDescriptorTC(DThread* aThread, TDes8& aString, TInt aIndex, TInt aPosition) const;
    TInt SetDeviceStringDescriptorTC(DThread* aThread, const TDes8& aString, TInt aIndex, TInt aPosition);
    TInt RemoveDeviceStringDescriptor(TInt aIndex, TInt aPosition);
    void ExchangeStringDescriptor(TInt aIndex, const TUsbcStringDescriptor* aDesc);
    TBool AnyStringDescriptors() const;
    TBool StringDescriptorExists(TInt aIndex) const;
    TInt FindAvailableStringPos() const;

private:
    // Data members
    RPointerArray<TUsbcDescriptorBase> iDescriptors;
    RPointerArray<TUsbcStringDescriptorBase> iStrings;
    TInt iIfcIdx;
    TUint8* const iEp0_TxBuf;                                // points to the controller's ep0 TX buffer
    TBool iHighSpeed;                                        // true if currently operating at high-speed
    };


#endif    // __USBCDESC_H__