// 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 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/drivers/usbcc/descriptors.cpp

// Platform independent layer (PIL) of the USB Device controller driver:

// USB descriptor handling and management.

// 

//

/**

 @file descriptors.cpp

 @internalTechnology

*/

#include <kernel/kern_priv.h>

// #include <drivers/usbc.h>

#include <usb/usbc.h>

// Debug Support

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

// --- TUsbcDescriptorBase

TUsbcDescriptorBase::TUsbcDescriptorBase()

    :

#ifdef USB_SUPPORTS_SET_DESCRIPTOR_REQUEST

    iIndex(0),

#endif

    iBufPtr(NULL, 0)

    {

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

    }

TUsbcDescriptorBase::~TUsbcDescriptorBase()

    {

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

    }

void TUsbcDescriptorBase::SetByte(TInt aPosition, TUint8 aValue)

    {

    iBufPtr[aPosition] = aValue;

    }

void TUsbcDescriptorBase::SetWord(TInt aPosition, TUint16 aValue)

    {

    *reinterpret_cast<TUint16*>(&iBufPtr[aPosition]) = SWAP_BYTES_16(aValue);

    }

TUint8 TUsbcDescriptorBase::Byte(TInt aPosition) const

    {

    return iBufPtr[aPosition];

    }

TUint16 TUsbcDescriptorBase::Word(TInt aPosition) const

    {

    return SWAP_BYTES_16(*reinterpret_cast<const TUint16*>(&iBufPtr[aPosition]));

    }

void TUsbcDescriptorBase::GetDescriptorData(TDes8& aBuffer) const

    {

    aBuffer = iBufPtr;

    }

TInt TUsbcDescriptorBase::GetDescriptorData(TUint8* aBuffer) const

    {

    memcpy(aBuffer, iBufPtr.Ptr(), Size());

    return Size();

    }

TInt TUsbcDescriptorBase::GetDescriptorData(TUint8* aBuffer, TUint aMaxSize) const

    {

    if (aMaxSize < Size())

        {

        // No use to copy only half a descriptor

        return 0;

        }

    return GetDescriptorData(aBuffer);

    }

const TDes8& TUsbcDescriptorBase::DescriptorData() const

    {

    return iBufPtr;

    }

TDes8& TUsbcDescriptorBase::DescriptorData()

    {

    return iBufPtr;

    }

TUint TUsbcDescriptorBase::Size() const

    {

    return iBufPtr.Size();

    }

TUint8 TUsbcDescriptorBase::Type() const

    {

    return iBufPtr[1];

    }

void TUsbcDescriptorBase::UpdateFs()

    {

    // virtual function can be overridden in derived classes.

    return;

    }

void TUsbcDescriptorBase::UpdateHs()

    {

    // virtual function can be overridden in derived classes.

    return;

    }

void TUsbcDescriptorBase::SetBufferPointer(const TDesC8& aDes)

    {

    iBufPtr.Set(const_cast<TUint8*>(aDes.Ptr()), aDes.Size(), aDes.Size());

    }

// --- TUsbcDeviceDescriptor

TUsbcDeviceDescriptor::TUsbcDeviceDescriptor()

    : iBuf()

    {

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

    }

TUsbcDeviceDescriptor* TUsbcDeviceDescriptor::New(TUint8 aDeviceClass, TUint8 aDeviceSubClass,

                                                  TUint8 aDeviceProtocol, TUint8 aMaxPacketSize0,

                                                  TUint16 aVendorId, TUint16 aProductId,

                                                  TUint16 aDeviceRelease, TUint8 aNumConfigurations)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDeviceDescriptor::New()"));

    TUsbcDeviceDescriptor* self = new TUsbcDeviceDescriptor();

    if (self)

        {

        if (self->Construct(aDeviceClass, aDeviceSubClass, aDeviceProtocol, aMaxPacketSize0, aVendorId,

                            aProductId, aDeviceRelease, aNumConfigurations) != KErrNone)

            {

            delete self;

            return NULL;

            }

        }

    return self;

    }

TInt TUsbcDeviceDescriptor::Construct(TUint8 aDeviceClass, TUint8 aDeviceSubClass, TUint8 aDeviceProtocol,

                                      TUint8 aMaxPacketSize0, TUint16 aVendorId, TUint16 aProductId,

                                      TUint16 aDeviceRelease, TUint8 aNumConfigurations)

    {

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

    iBuf.SetMax();

    SetBufferPointer(iBuf);

    iBuf[0] = iBuf.Size();                                    // bLength

    iBuf[1] = KUsbDescType_Device;                            // bDescriptorType

    SetWord(2, KUsbcUsbVersion);                            // bcdUSB

    iBuf[4] = aDeviceClass;                                    // bDeviceClass

    iBuf[5] = aDeviceSubClass;                                // bDeviceSubClass

    iBuf[6] = aDeviceProtocol;                                // bDeviceProtocol

    iBuf[7] = aMaxPacketSize0;                                // bMaxPacketSize0

    SetWord(8, aVendorId);                                    // idVendor

    SetWord(10, aProductId);                                // idProduct

    SetWord(12, aDeviceRelease);                            // bcdDevice

    iBuf[14] = 0;                                            // iManufacturer

    iBuf[15] = 0;                                            // iProduct

    iBuf[16] = 0;                                            // iSerialNumber

    iBuf[17] = aNumConfigurations;                            // bNumConfigurations

    iEp0Size_Fs = aMaxPacketSize0;

    return KErrNone;

    }

void TUsbcDeviceDescriptor::UpdateFs()

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDeviceDescriptor::UpdateFs()"));

    SetByte(7, iEp0Size_Fs);                                // bMaxPacketSize0

    }

void TUsbcDeviceDescriptor::UpdateHs()

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDeviceDescriptor::UpdateHs()"));

    SetByte(7, 64);                                            // bMaxPacketSize0

    }

// --- TUsbcDeviceQualifierDescriptor

TUsbcDeviceQualifierDescriptor::TUsbcDeviceQualifierDescriptor()

    : iBuf()

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDeviceDescriptor::TUsbcDeviceQualifierDescriptor()"));

    }

TUsbcDeviceQualifierDescriptor* TUsbcDeviceQualifierDescriptor::New(TUint8 aDeviceClass,

                                                                    TUint8 aDeviceSubClass,

                                                                    TUint8 aDeviceProtocol,

                                                                    TUint8 aMaxPacketSize0,

                                                                    TUint8 aNumConfigurations,

                                                                    TUint8 aReserved)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDeviceQualifierDescriptor::New()"));

    TUsbcDeviceQualifierDescriptor* self = new TUsbcDeviceQualifierDescriptor();

    if (self)

        {

        if (self->Construct(aDeviceClass, aDeviceSubClass, aDeviceProtocol, aMaxPacketSize0,

                            aNumConfigurations, aReserved) != KErrNone)

            {

            delete self;

            return NULL;

            }

        }

    return self;

    }

TInt TUsbcDeviceQualifierDescriptor::Construct(TUint8 aDeviceClass, TUint8 aDeviceSubClass,

                                               TUint8 aDeviceProtocol, TUint8 aMaxPacketSize0,

                                               TUint8 aNumConfigurations, TUint8 aReserved)

    {

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

    iBuf.SetMax();

    SetBufferPointer(iBuf);

    iBuf[0] = iBuf.Size();                                    // bLength

    iBuf[1] = KUsbDescType_DeviceQualifier;                    // bDescriptorType

    SetWord(2, KUsbcUsbVersion);                            // bcdUSB

    iBuf[4] = aDeviceClass;                                    // bDeviceClass

    iBuf[5] = aDeviceSubClass;                                // bDeviceSubClass

    iBuf[6] = aDeviceProtocol;                                // bDeviceProtocol

    iBuf[7] = aMaxPacketSize0;                                // bMaxPacketSize0

    iBuf[8] = aNumConfigurations;                            // bNumConfigurations

    if (aReserved) aReserved = 0;

    iBuf[9] = aReserved;                                    // Reserved for future use, must be zero

    iEp0Size_Fs = aMaxPacketSize0;

    return KErrNone;

    }

void TUsbcDeviceQualifierDescriptor::UpdateFs()

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDeviceQualifierDescriptor::UpdateFs()"));

    // Here we do exactly the opposite of what's done in the Device descriptor (as this one's

    // documenting the 'other than the current speed').

    SetByte(7, 64);                                            // bMaxPacketSize0

    }

void TUsbcDeviceQualifierDescriptor::UpdateHs()

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDeviceQualifierDescriptor::UpdateHs()"));

    // Here we do exactly the opposite of what's done in the Device descriptor (as this one's

    // documenting the 'other than the current speed').

    SetByte(7, iEp0Size_Fs);                                // bMaxPacketSize0

    }

// --- TUsbcConfigDescriptor

TUsbcConfigDescriptor::TUsbcConfigDescriptor()

    : iBuf()

    {

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

    }

TUsbcConfigDescriptor* TUsbcConfigDescriptor::New(TUint8 aConfigurationValue, TBool aSelfPowered,

                                                  TBool aRemoteWakeup, TUint16 aMaxPower)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcConfigDescriptor::New()"));

    TUsbcConfigDescriptor* self = new TUsbcConfigDescriptor();

    if (self)

        {

        if (self->Construct(aConfigurationValue, aSelfPowered, aRemoteWakeup, aMaxPower) != KErrNone)

            {

            delete self;

            return NULL;

            }

        }

    return self;

    }

TInt TUsbcConfigDescriptor::Construct(TUint8 aConfigurationValue, TBool aSelfPowered,

                                       TBool aRemoteWakeup, TUint16 aMaxPower)

    {

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

    iBuf.SetMax();

    SetBufferPointer(iBuf);

    iBuf[0] = iBuf.Size();                                    // bLength

    iBuf[1] = KUsbDescType_Config;                            // bDescriptorType

    SetWord(2, KUsbDescSize_Config);                        // wTotalLength

    iBuf[4] = 0;                                            // bNumInterfaces

    iBuf[5] = aConfigurationValue;                            // bConfigurationValue

    iBuf[6] = 0;                                            // iConfiguration

    iBuf[7] = 0x80 |

        (aSelfPowered ? KUsbDevAttr_SelfPowered : 0) |

        (aRemoteWakeup ? KUsbDevAttr_RemoteWakeup : 0);        // bmAttributes (bit 7 always 1)

    if (aMaxPower > 510)

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Invalid value for bMaxPower: %d", aMaxPower));

    iBuf[8] = aMaxPower / 2;                                // bMaxPower (2mA units!)

    return KErrNone;

    }

// --- TUsbcInterfaceDescriptor

TUsbcInterfaceDescriptor::TUsbcInterfaceDescriptor()

    : iBuf()

    {

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

    }

TUsbcInterfaceDescriptor* TUsbcInterfaceDescriptor::New(TUint8 aInterfaceNumber, TUint8 aAlternateSetting,

                                                        TInt aNumEndpoints, const TUsbcClassInfo& aClassInfo)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcInterfaceDescriptor::New()"));

    TUsbcInterfaceDescriptor* self = new TUsbcInterfaceDescriptor();

    if (self)

        {

        if (self->Construct(aInterfaceNumber, aAlternateSetting, aNumEndpoints, aClassInfo) != KErrNone)

            {

            delete self;

            return NULL;

            }

        }

    return self;

    }

TInt TUsbcInterfaceDescriptor::Construct(TUint8 aInterfaceNumber, TUint8 aAlternateSetting,

                                         TInt aNumEndpoints, const TUsbcClassInfo& aClassInfo)

    {

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

    iBuf.SetMax();

    SetBufferPointer(iBuf);

    iBuf[0] = iBuf.Size();                                    // bLength

    iBuf[1] = KUsbDescType_Interface;                        // bDescriptorType

    iBuf[2] = aInterfaceNumber;                                // bInterfaceNumber

    iBuf[3] = aAlternateSetting;                            // bAlternateSetting

    iBuf[4] = aNumEndpoints;                                // bNumEndpoints

    iBuf[5] = aClassInfo.iClassNum;                            // bInterfaceClass

    iBuf[6] = aClassInfo.iSubClassNum;                        // bInterfaceSubClass

    iBuf[7] = aClassInfo.iProtocolNum;                        // bInterfaceProtocol

    iBuf[8] = 0;                                            // iInterface

    return KErrNone;

    }

// --- TUsbcEndpointDescriptorBase

TUsbcEndpointDescriptorBase::TUsbcEndpointDescriptorBase()

    {

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

    }

TInt TUsbcEndpointDescriptorBase::Construct(const TUsbcEndpointInfo& aEpInfo)

    {

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

    //  Adjust FS/HS endpoint sizes

    if (aEpInfo.AdjustEpSizes(iEpSize_Fs, iEpSize_Hs) != KErrNone)

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Unknown endpoint type: %d", aEpInfo.iType));

        }

    __KTRACE_OPT(KUSB, Kern::Printf("  Now set: iEpSize_Fs=%d iEpSize_Hs=%d (aEpInfo.iSize=%d)",

                                    iEpSize_Fs, iEpSize_Hs, aEpInfo.iSize));

    //  Adjust HS endpoint size for additional transactions

    if ((aEpInfo.iType == UsbShai::KUsbEpTypeIsochronous) || (aEpInfo.iType == UsbShai::KUsbEpTypeInterrupt))

        {

        if ((aEpInfo.iTransactions > 0) && (aEpInfo.iTransactions < 3))

            {

            // Bits 12..11 specify the number of additional transactions per microframe

            iEpSize_Hs |= (aEpInfo.iTransactions << 12);

            __KTRACE_OPT(KUSB, Kern::Printf("  Adjusted for add. transact.: iEpSize_Hs=0x%02x "

                                            "(aEpInfo.iTransactions=%d)",

                                            iEpSize_Hs, aEpInfo.iTransactions));

            }

        else if (aEpInfo.iTransactions != 0)

            {

            __KTRACE_OPT(KPANIC, Kern::Printf("  Warning: Invalid iTransactions value: %d (ignored)",

                                              aEpInfo.iTransactions));

            }

        }

    //  Adjust HS polling interval

    TUsbcEndpointInfo info(aEpInfo);                        // create local writeable copy

    if (info.AdjustPollInterval() != KErrNone)

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Unknown ep type (%d) or invalid interval value (%d)",

                                          info.iType, info.iInterval));

        }

    iInterval_Fs = info.iInterval;

    iInterval_Hs = info.iInterval_Hs;

    __KTRACE_OPT(KUSB, Kern::Printf("  Now set: iInterval_Fs=%d iInterval_Hs=%d",

                                    iInterval_Fs, iInterval_Hs));

    return KErrNone;

    }

void TUsbcEndpointDescriptorBase::UpdateFs()

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpointDescriptorBase::UpdateFs()"));

    // (TUsbcEndpointDescriptorBase's FS/HS endpoint sizes and interval values got

    //  adjusted in its Construct() method.)

    SetWord(4, iEpSize_Fs);                                    // wMaxPacketSize

    SetByte(6, iInterval_Fs);                                // bInterval

    }

void TUsbcEndpointDescriptorBase::UpdateHs()

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpointDescriptorBase::UpdateHs()"));

    // (TUsbcEndpointDescriptorBase's FS/HS endpoint sizes and interval values get

    //  adjusted in its Construct() method.)

    SetWord(4, iEpSize_Hs);                                    // wMaxPacketSize

    SetByte(6, iInterval_Hs);                                // bInterval

    }

// --- TUsbcEndpointDescriptor

TUsbcEndpointDescriptor::TUsbcEndpointDescriptor()

    : iBuf()

    {

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

    }

TUsbcEndpointDescriptor* TUsbcEndpointDescriptor::New(TUint8 aEndpointAddress,

                                                      const TUsbcEndpointInfo& aEpInfo)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpointDescriptor::New()"));

    TUsbcEndpointDescriptor* self = new TUsbcEndpointDescriptor();

    if (self)

        {

        if (self->Construct(aEndpointAddress, aEpInfo) != KErrNone)

            {

            delete self;

            return NULL;

            }

        }

    return self;

    }

TInt TUsbcEndpointDescriptor::Construct(TUint8 aEndpointAddress, const TUsbcEndpointInfo& aEpInfo)

    {

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

    (void) TUsbcEndpointDescriptorBase::Construct(aEpInfo);    // Init Base class

    iBuf.SetMax();

    SetBufferPointer(iBuf);

    iBuf[0] = iBuf.Size();                                    // bLength

    iBuf[1] = KUsbDescType_Endpoint;                        // bDescriptorType

    iBuf[2] = aEndpointAddress;                                // bEndpointAddress

    iBuf[3] = EpTypeMask2Value(aEpInfo.iType);                // bmAttributes

    SetWord(4, iEpSize_Fs);                                    // wMaxPacketSize (default is FS)

    iBuf[6] = iInterval_Fs;                                    // bInterval (default is FS)

    return KErrNone;

    }

// --- TUsbcAudioEndpointDescriptor

TUsbcAudioEndpointDescriptor::TUsbcAudioEndpointDescriptor()

    : iBuf()

    {

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

    }

TUsbcAudioEndpointDescriptor* TUsbcAudioEndpointDescriptor::New(TUint8 aEndpointAddress,

                                                                const TUsbcEndpointInfo& aEpInfo)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcAudioEndpointDescriptor::New()"));

    TUsbcAudioEndpointDescriptor* self = new TUsbcAudioEndpointDescriptor();

    if (self)

        {

        if (self->Construct(aEndpointAddress, aEpInfo) != KErrNone)

            {

            delete self;

            return NULL;

            }

        }

    return self;

    }

TInt TUsbcAudioEndpointDescriptor::Construct(TUint8 aEndpointAddress, const TUsbcEndpointInfo& aEpInfo)

    {

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

    (void) TUsbcEndpointDescriptorBase::Construct(aEpInfo);    // Init Base class

    iBuf.SetMax();

    SetBufferPointer(iBuf);

    iBuf[0] = iBuf.Size();                                    // bLength

    iBuf[1] = KUsbDescType_Endpoint;                        // bDescriptorType

    iBuf[2] = aEndpointAddress;                                // bEndpointAddress

    iBuf[3] = EpTypeMask2Value(aEpInfo.iType);                // bmAttributes

    SetWord(4, iEpSize_Fs);                                    // wMaxPacketSize (default is FS)

    iBuf[6] = iInterval_Fs;                                    // bInterval (default is FS)