diff -r f92a4f87e424 -r 012cc2ee6408 usbdrv/peripheral/pdd/pil/src/descriptors.cpp
--- a/usbdrv/peripheral/pdd/pil/src/descriptors.cpp	Tue Aug 31 17:01:47 2010 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,2362 +0,0 @@
-// 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)
-    iBuf[7] = 0;
-    iBuf[8] = 0;
-    return KErrNone;
-    }
-
-
-// --- TUsbcOtgDescriptor
-
-TUsbcOtgDescriptor* TUsbcOtgDescriptor::New(TBool aHnpSupport, TBool aSrpSupport)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcOtgDescriptor::New()"));
-    TUsbcOtgDescriptor* self = new TUsbcOtgDescriptor();
-    if (self && (self->Construct(aHnpSupport, aSrpSupport) != KErrNone))
-        {
-        delete self;
-        return NULL;
-        }
-    return self;
-    }
-
-
-TUsbcOtgDescriptor::TUsbcOtgDescriptor()
-    : iBuf()
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcOtgDescriptor::TUsbcOtgDescriptor()"));
-    }
-
-
-TInt TUsbcOtgDescriptor::Construct(TBool aHnpSupport, TBool aSrpSupport)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcOtgDescriptor::Construct()"));
-    iBuf.SetMax();
-    SetBufferPointer(iBuf);
-    iBuf[0] = iBuf.Size();                                    // bLength
-    iBuf[1] = KUsbDescType_Otg;                                // bDescriptorType
-    iBuf[2] = (aHnpSupport ? KUsbOtgAttr_HnpSupp : 0) |
-        (aSrpSupport ? KUsbOtgAttr_SrpSupp : 0);            // bmAttributes
-    return KErrNone;
-    }
-
-
-// --- TUsbcClassSpecificDescriptor
-
-TUsbcClassSpecificDescriptor::TUsbcClassSpecificDescriptor()
-    : iBuf(NULL)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcClassSpecificDescriptor::TUsbcClassSpecificDescriptor()"));
-    }
-
-
-TUsbcClassSpecificDescriptor::~TUsbcClassSpecificDescriptor()
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcClassSpecificDescriptor::~TUsbcClassSpecificDescriptor()"));
-    delete iBuf;
-    }
-
-
-TUsbcClassSpecificDescriptor* TUsbcClassSpecificDescriptor::New(TUint8 aType, TInt aSize)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcClassSpecificDescriptor::New()"));
-    TUsbcClassSpecificDescriptor* self = new TUsbcClassSpecificDescriptor();
-    if (self)
-        {
-        if (self->Construct(aType, aSize) != KErrNone)
-            {
-            delete self;
-            return NULL;
-            }
-        }
-    return self;
-    }
-
-
-TInt TUsbcClassSpecificDescriptor::Construct(TUint8 aType, TInt aSize)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcClassSpecificDescriptor::Construct()"));
-    iBuf = HBuf8::New(aSize);
-    if (!iBuf)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Allocation of CS desc buffer failed"));
-        return KErrNoMemory;
-        }
-    iBuf->SetMax();
-    SetBufferPointer(*iBuf);
-    SetByte(1, aType);                                        // bDescriptorType
-    return KErrNone;
-    }
-
-
-// --- TUsbcStringDescriptorBase
-
-TUsbcStringDescriptorBase::TUsbcStringDescriptorBase()
-    : /*iIndex(0),*/ iSBuf(0), iBufPtr(NULL, 0)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcStringDescriptorBase::TUsbcStringDescriptorBase()"));
-    }
-
-
-TUsbcStringDescriptorBase::~TUsbcStringDescriptorBase()
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcStringDescriptorBase::~TUsbcStringDescriptorBase()"));
-    }
-
-
-TUint16 TUsbcStringDescriptorBase::Word(TInt aPosition) const
-    {
-    if (aPosition <= 1)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Word(%d) in string descriptor "
-                                          "(TUsbcStringDescriptorBase::Word)", aPosition));
-        return 0;
-        }
-    else
-        {
-        // since iBufPtr[0] is actually string descriptor byte index 2,
-        // we have to subtract 2 from the absolute position.
-        return SWAP_BYTES_16(*reinterpret_cast<const TUint16*>(&iBufPtr[aPosition - 2]));
-        }
-    }
-
-
-void TUsbcStringDescriptorBase::SetWord(TInt aPosition, TUint16 aValue)
-    {
-    if (aPosition <= 1)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: SetWord(%d) in string descriptor "
-                                          "(TUsbcStringDescriptorBase::SetWord)", aPosition));
-        return;
-        }
-    else
-        {
-        // since iBufPtr[0] is actually string descriptor byte index 2,
-        // we have to subtract 2 from the absolute position.
-        *reinterpret_cast<TUint16*>(&iBufPtr[aPosition - 2]) = SWAP_BYTES_16(aValue);
-        }
-    }
-
-
-TInt TUsbcStringDescriptorBase::GetDescriptorData(TUint8* aBuffer) const
-    {
-    aBuffer[0] = iSBuf[0];
-    aBuffer[1] = iSBuf[1];
-    memcpy(&aBuffer[2], iBufPtr.Ptr(), iBufPtr.Size());
-    return Size();
-    }
-
-
-TInt TUsbcStringDescriptorBase::GetDescriptorData(TUint8* aBuffer, TUint aMaxSize) const
-    {
-    if (aMaxSize < Size())
-        {
-        // No use to copy only half a string
-        return 0;
-        }
-    return GetDescriptorData(aBuffer);
-    }
-
-
-const TDes8& TUsbcStringDescriptorBase::StringData() const
-    {
-    return iBufPtr;
-    }
-
-
-TDes8& TUsbcStringDescriptorBase::StringData()
-    {
-    return iBufPtr;
-    }
-
-
-TUint TUsbcStringDescriptorBase::Size() const
-    {
-    return iSBuf[0];
-    }
-
-
-void TUsbcStringDescriptorBase::SetBufferPointer(const TDesC8& aDes)
-    {
-    iBufPtr.Set(const_cast<TUint8*>(aDes.Ptr()), aDes.Size(), aDes.Size());
-    }
-
-
-// --- TUsbcStringDescriptor
-
-TUsbcStringDescriptor::TUsbcStringDescriptor()
-    : iBuf(NULL)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcStringDescriptor::TUsbcStringDescriptor()"));
-    }
-
-
-TUsbcStringDescriptor::~TUsbcStringDescriptor()
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcStringDescriptor::~TUsbcStringDescriptor()"));
-    delete iBuf;
-    }
-
-
-TUsbcStringDescriptor* TUsbcStringDescriptor::New(const TDesC8& aString)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcStringDescriptor::New"));
-    TUsbcStringDescriptor* self = new TUsbcStringDescriptor();
-    if (self)
-        {
-        if (self->Construct(aString) != KErrNone)
-            {
-            delete self;
-            return NULL;
-            }
-        }
-    return self;
-    }
-
-
-TInt TUsbcStringDescriptor::Construct(const TDesC8& aString)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcStringDescriptor::Construct"));
-    iBuf = HBuf8::New(aString.Size());                        // bytes, not UNICODE chars
-    if (!iBuf)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Allocation of string buffer failed"));
-        return KErrNoMemory;
-        }
-    iBuf->SetMax();
-    SetBufferPointer(*iBuf);
-    iBufPtr.Copy(aString);
-    iSBuf.SetMax();
-    iSBuf[0] = iBuf->Size() + 2;                            // Bytes
-    iSBuf[1] = KUsbDescType_String;
-    return KErrNone;
-    }
-
-
-// --- TUsbcLangIdDescriptor
-
-TUsbcLangIdDescriptor::TUsbcLangIdDescriptor()
-    : iBuf(NULL)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcLangIdDescriptor::TUsbcLangIdDescriptor()"));
-    }
-
-
-TUsbcLangIdDescriptor::~TUsbcLangIdDescriptor()
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcLangIdDescriptor::~TUsbcLangIdDescriptor()"));
-    }
-
-
-TUsbcLangIdDescriptor* TUsbcLangIdDescriptor::New(TUint16 aLangId)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcLangIdDescriptor::New"));
-    TUsbcLangIdDescriptor* self = new TUsbcLangIdDescriptor();
-    if (self)
-        {
-        if (self->Construct(aLangId) != KErrNone)
-            {
-            delete self;
-            return NULL;
-            }
-        }
-    return self;
-    }
-
-
-TInt TUsbcLangIdDescriptor::Construct(TUint16 aLangId)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcLangIdDescriptor::Construct"));
-    iBuf.SetMax();
-    SetBufferPointer(iBuf);
-    iBufPtr[0] = LowByte(SWAP_BYTES_16(aLangId));            // Language ID value
-    iBufPtr[1] = HighByte(SWAP_BYTES_16(aLangId));
-    iSBuf.SetMax();
-    iSBuf[0] = iBuf.Size() + 2;                                // Bytes
-    iSBuf[1] = KUsbDescType_String;
-    return KErrNone;
-    }
-
-
-// --- TUsbcDescriptorPool
-
-TUsbcDescriptorPool::TUsbcDescriptorPool(TUint8* aEp0_TxBuf)
-//
-//    The constructor for this class.
-//
-    : iDescriptors(), iStrings(), iIfcIdx(0), iEp0_TxBuf(aEp0_TxBuf), iHighSpeed(EFalse)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::TUsbcDescriptorPool()"));
-    }
-
-
-TUsbcDescriptorPool::~TUsbcDescriptorPool()
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::~TUsbcDescriptorPool()"));
-    // The destructor of each <class T> object is called before the objects themselves are destroyed.
-    __KTRACE_OPT(KUSB, Kern::Printf("  iDescriptors.Count(): %d", iDescriptors.Count()));
-    iDescriptors.ResetAndDestroy();
-    __KTRACE_OPT(KUSB, Kern::Printf("  iStrings.Count(): %d", iStrings.Count()));
-    iStrings.ResetAndDestroy();
-    }
-
-
-TInt TUsbcDescriptorPool::Init(TUsbcDeviceDescriptor* aDeviceDesc, TUsbcConfigDescriptor* aConfigDesc,
-                               TUsbcLangIdDescriptor* aLangId, TUsbcStringDescriptor* aManufacturer,
-                               TUsbcStringDescriptor* aProduct, TUsbcStringDescriptor* aSerialNum,
-                               TUsbcStringDescriptor* aConfig, TUsbcOtgDescriptor* aOtgDesc)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::Init()"));
-    if (!aDeviceDesc || !aConfigDesc)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: No Device or Config descriptor specified"));
-        return KErrArgument;
-        }
-    for (TInt n = 0; n < KDescPosition_FirstAvailable; n++)
-        {
-        iDescriptors.Append(NULL);
-        }
-    __ASSERT_DEBUG((iDescriptors.Count() == KDescPosition_FirstAvailable),
-                   Kern::Printf("  Error: iDescriptors.Count() (%d) != KDescPosition_FirstAvailable (%d)",
-                                iDescriptors.Count(), KDescPosition_FirstAvailable));
-    iDescriptors[KDescPosition_Device] = aDeviceDesc;
-    iDescriptors[KDescPosition_Config] = aConfigDesc;
-    if (aOtgDesc)
-        {
-        iDescriptors[KDescPosition_Otg] = aOtgDesc;
-        // Update the config descriptor's wTotalLength field
-        UpdateConfigDescriptorLength(KUsbDescSize_Otg);
-        }
-    if (!aLangId)
-        {
-        // USB spec 9.6.7 says: "String index zero for all languages returns a string descriptor
-        // that contains an array of two-byte LANGID codes supported by the device. ...
-        // USB devices that omit all string descriptors must not return an array of LANGID codes."
-        // So if we have at least one string descriptor, we must also have a LANGID descriptor.
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: No LANGID string descriptor specified"));
-        return KErrArgument;
-        }
-    iStrings.Insert(aLangId, KStringPosition_Langid);
-    iStrings.Insert(aManufacturer, KStringPosition_Manufact);
-    iStrings.Insert(aProduct, KStringPosition_Product);
-    iStrings.Insert(aSerialNum, KStringPosition_Serial);
-    iStrings.Insert(aConfig, KStringPosition_Config);
-    __ASSERT_DEBUG((iStrings.Count() == 5),
-                   Kern::Printf("  Error: iStrings.Count() != 5 (%d)", iStrings.Count()));
-#ifdef _DEBUG
-    for (TInt i = KStringPosition_Langid; i <= KStringPosition_Config; i++)
-        {
-        __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool.iStrings[%d] = 0x%x", i, iStrings[i]));
-        }
-#endif
-    // Set string indices
-    if (aManufacturer)
-        iDescriptors[KDescPosition_Device]->SetByte(KUsbDescStringIndex_Manufact,
-                                                    KStringPosition_Manufact);
-    if (aProduct)
-        iDescriptors[KDescPosition_Device]->SetByte(KUsbDescStringIndex_Product,
-                                                    KStringPosition_Product);
-    if (aSerialNum)
-        iDescriptors[KDescPosition_Device]->SetByte(KUsbDescStringIndex_Serial,
-                                                    KStringPosition_Serial);
-    if (aConfig)
-        iDescriptors[KDescPosition_Config]->SetByte(KUsbDescStringIndex_Config,
-                                                    KStringPosition_Config);
-    return KErrNone;
-    }
-
-
-TInt TUsbcDescriptorPool::InitHs()
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::InitHs()"));
-    __ASSERT_DEBUG((iDescriptors.Count() >= KDescPosition_FirstAvailable),
-                   Kern::Printf("  Error: Call Init() first)"));
-
-    TUsbcDeviceQualifierDescriptor* const dq_desc = TUsbcDeviceQualifierDescriptor::New(
-        iDescriptors[KDescPosition_Device]->Byte(4),        // aDeviceClass
-        iDescriptors[KDescPosition_Device]->Byte(5),        // aDeviceSubClass
-        iDescriptors[KDescPosition_Device]->Byte(6),        // aDeviceProtocol
-        iDescriptors[KDescPosition_Device]->Byte(7),        // aMaxPacketSize0
-        iDescriptors[KDescPosition_Device]->Byte(17));        // aNumConfigurations
-    if (!dq_desc)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for dev qualif desc failed."));
-        return KErrGeneral;
-        }
-    iDescriptors[KDescPosition_DeviceQualifier] = dq_desc;
-
-    TUsbcOtherSpeedConfigDescriptor* const osc_desc = TUsbcOtherSpeedConfigDescriptor::New(
-        iDescriptors[KDescPosition_Config]->Byte(5),        // aConfigurationValue
-        iDescriptors[KDescPosition_Config]->Byte(7) & KUsbDevAttr_SelfPowered, // aSelfPowered
-        iDescriptors[KDescPosition_Config]->Byte(7) & KUsbDevAttr_RemoteWakeup,    // aRemoteWakeup
-        iDescriptors[KDescPosition_Config]->Byte(8) * 2);    // aMaxPower (mA)
-    if (!osc_desc)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for other speed conf desc failed."));
-        return KErrGeneral;
-        }
-
-    // We need to set the bDescriptorType field manually, as that's the only one
-    // that differs from a Configuration descriptor.
-    osc_desc->SetByte(1, KUsbDescType_OtherSpeedConfig);
-
-    // Also, initially we set the iConfiguration string index to the same value as
-    // in the Configuration descriptor.
-    osc_desc->SetByte(KUsbDescStringIndex_Config,
-                      iDescriptors[KDescPosition_Config]->Byte(KUsbDescStringIndex_Config));
-
-    iDescriptors[KDescPosition_OtherSpeedConfig] = osc_desc;
-
-    return KErrNone;
-    }
-
-
-TInt TUsbcDescriptorPool::UpdateDescriptorsFs()
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::UpdateDescriptorsFs()"));
-    const TInt count = iDescriptors.Count();
-    for (TInt i = KDescPosition_FirstAvailable; i < count; i++)
-        {
-        TUsbcDescriptorBase* const ptr = iDescriptors[i];
-        ptr->UpdateFs();
-        }
-    iHighSpeed = EFalse;
-    return KErrNone;
-    }
-
-
-TInt TUsbcDescriptorPool::UpdateDescriptorsHs()
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::UpdateDescriptorsHs()"));
-    const TInt count = iDescriptors.Count();
-    for (TInt i = KDescPosition_FirstAvailable; i < count; i++)
-        {
-        TUsbcDescriptorBase* const ptr = iDescriptors[i];
-        ptr->UpdateHs();
-        }
-    iHighSpeed = ETrue;
-    return KErrNone;
-    }
-
-
-//
-// An error can be indicated by either a return value != KErrNone or by a descriptor size == 0.
-//
-TInt TUsbcDescriptorPool::FindDescriptor(TUint8 aType, TUint8 aIndex, TUint16 aLangid, TInt& aSize) const
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::FindDescriptor()"));
-    TInt result = KErrGeneral;
-    switch (aType)
-        {
-    case KUsbDescType_Device:
-        if (aLangid != 0)
-            {
-            __KTRACE_OPT(KPANIC, Kern::Printf("  Error: bad langid: 0x%04x", aLangid));
-            }
-        else if (aIndex > 0)
-            {
-            __KTRACE_OPT(KPANIC, Kern::Printf("  Error: bad device index: %d", aIndex));
-            }
-        else
-            {
-            aSize = GetDeviceDescriptor(KDescPosition_Device);
-            result = KErrNone;
-            }
-        break;
-    case KUsbDescType_Config:
-        if (aLangid != 0)
-            {
-            __KTRACE_OPT(KPANIC, Kern::Printf("  Error: bad langid: 0x%04x", aLangid));
-            }
-        else if (aIndex > 0)
-            {
-            __KTRACE_OPT(KPANIC, Kern::Printf("  Error: bad config index: %d", aIndex));
-            }
-        else
-            {
-            aSize = GetConfigurationDescriptor(KDescPosition_Config);
-            result = KErrNone;
-            }
-        break;
-    case KUsbDescType_DeviceQualifier:
-        if (aLangid != 0)
-            {
-            __KTRACE_OPT(KPANIC, Kern::Printf("  Error: bad langid: 0x%04x", aLangid));
-            }
-        else if (aIndex > 0)
-            {
-            __KTRACE_OPT(KPANIC, Kern::Printf("  Error: bad device index: %d", aIndex));
-            }
-        else
-            {
-            aSize = GetDeviceDescriptor(KDescPosition_DeviceQualifier);
-            result = KErrNone;
-            }
-        break;
-    case KUsbDescType_OtherSpeedConfig:
-        if (aLangid != 0)
-            {
-            __KTRACE_OPT(KPANIC, Kern::Printf("  Error: bad langid: 0x%04x", aLangid));
-            }
-        else if (aIndex > 0)
-            {
-            __KTRACE_OPT(KPANIC, Kern::Printf("  Error: bad config index: %d", aIndex));
-            }
-        else
-            {
-            aSize = GetConfigurationDescriptor(KDescPosition_OtherSpeedConfig);
-            result = KErrNone;
-            }
-        break;
-    case KUsbDescType_Otg:
-        aSize = GetOtgDescriptor();
-        result = KErrNone;
-        break;
-    case KUsbDescType_String:
-        if (aIndex == 0)                                    // 0 addresses the LangId array
-            {
-            if (AnyStringDescriptors())
-                {
-                aSize = GetStringDescriptor(aIndex);
-                result = KErrNone;
-                }
-            else
-                {
-                __KTRACE_OPT(KUSB, Kern::Printf("  No string descriptors: not returning LANGID array"));
-                }
-            }
-        else
-            {
-               if (!aLangid)
-                   {
-                   __KTRACE_OPT(KUSB,
-                              Kern::Printf("  Strange: LANGID=0 for a $ descriptor (ignoring LANGID)"));
-                // The USB spec doesn't really say what to do in this case, but as there are host apps
-                // that fail if we return an error here, we choose to ignore the issue.
-                   }
-            else if (aLangid != iStrings[KStringPosition_Langid]->Word(2))
-                {
-                // We have only one (this) language
-                __KTRACE_OPT(KUSB,
-                             Kern::Printf("  Bad LANGID: 0x%04X requested, 0x%04X supported (ignoring LANGID)",
-                                          aLangid, iStrings[KStringPosition_Langid]->Word(2)));
-                // We could return an error here, but rather choose to ignore the discrepancy
-                // (the USB spec is not very clear what to do in such a case anyway).
-                }
-            aSize = GetStringDescriptor(aIndex);
-            result = KErrNone;
-            }
-        break;
-    case KUsbDescType_CS_Interface:
-        /* fall through */
-    case KUsbDescType_CS_Endpoint:
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Warning: finding of class specific descriptors not supported"));
-        break;
-    default:
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: unknown descriptor type requested: %d", aType));
-        break;
-        }
-    return result;
-    }
-
-
-void TUsbcDescriptorPool::InsertDescriptor(TUsbcDescriptorBase* aDesc)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::InsertDescriptor()"));
-    switch (aDesc->Type())
-        {
-    case KUsbDescType_Interface:
-        InsertIfcDesc(aDesc);
-        break;
-    case KUsbDescType_Endpoint:
-        InsertEpDesc(aDesc);
-        break;
-    default:
-        __KTRACE_OPT(KUSB, Kern::Printf("  Error: unsupported descriptor type"));
-        }
-    }
-
-
-void TUsbcDescriptorPool::SetIfcStringDescriptor(TUsbcStringDescriptor* aDesc, TInt aNumber, TInt aSetting)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::SetIfcDescriptor(%d, %d)", aNumber, aSetting));
-    const TInt i = FindIfcDescriptor(aNumber, aSetting);
-    if (i < 0)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Ifc descriptor not found (%d, %d)",
-                                          aNumber, aSetting));
-        return;
-        }
-    // Try to find available NULL postition
-    TInt str_idx = FindAvailableStringPos();
-    if (str_idx >= 0)
-        {
-        // Insert string descriptor for specified interface
-        ExchangeStringDescriptor(str_idx, aDesc);
-        }
-    else
-        {
-        // No NULL found - expand array
-        str_idx = iStrings.Count();
-        if (str_idx > 0xff)
-            {
-            __KTRACE_OPT(KPANIC, Kern::Printf("  Error: $ descriptor array full (idx=%d)", str_idx));
-            return;
-            }
-        while (str_idx < KStringPosition_FirstAvailable)
-            {
-            iStrings.Append(NULL);
-            str_idx = iStrings.Count();
-            }
-        // Append string descriptor for specified interface
-        iStrings.Append(aDesc);
-        }
-    // Update this ifc descriptor's string index field
-    iDescriptors[i]->SetByte(8, str_idx);
-    __KTRACE_OPT(KUSB, Kern::Printf("  String for ifc %d/%d (@ pos %d): \"%S\"", aNumber, aSetting, str_idx,
-                                    &iStrings[str_idx]->StringData()));
-    }
-
-
-void TUsbcDescriptorPool::DeleteIfcDescriptor(TInt aNumber, TInt aSetting)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::DeleteIfcDescriptor(%d, %d)", aNumber, aSetting));
-    const TInt i = FindIfcDescriptor(aNumber, aSetting);
-    if (i < 0)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: DeleteIfcDescriptor - descriptor not found (%d, %d)",
-                                          aNumber, aSetting));
-        return;
-        }
-    // Delete (if necessary) specified interface's string descriptor
-    const TInt si = iDescriptors[i]->Byte(8);
-    if (si != 0)
-        {
-        ExchangeStringDescriptor(si, NULL);
-        }
-    // Delete specified ifc setting + all its cs descriptors + all its endpoints + all their cs descriptors:
-    // find position of the next interface descriptor: we need to delete everything in between
-    const TInt count = iDescriptors.Count();
-    TInt j = i, n = 1;
-    while (++j < count && iDescriptors[j]->Type() != KUsbDescType_Interface)
-        ++n;
-    DeleteDescriptors(i, n);
-    // Update all the following interfaces' bInterfaceNumber field if required
-    // (because those descriptors might have moved down by one position)
-    UpdateIfcNumbers(aNumber);
-    iIfcIdx = 0;                                            // ifc index no longer valid
-    }
-
-
-// The TC in many of the following functions stands for 'ThreadCopy',
-// because that's what's happening there.
-
-TInt TUsbcDescriptorPool::GetDeviceDescriptorTC(DThread* aThread, TDes8& aBuffer) const
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::GetDeviceDescriptorTC()"));
-    return Kern::ThreadDesWrite(aThread, &aBuffer, iDescriptors[KDescPosition_Device]->DescriptorData(), 0);
-    }
-
-
-TInt TUsbcDescriptorPool::SetDeviceDescriptorTC(DThread* aThread, const TDes8& aBuffer)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::SetDeviceDescriptorTC()"));
-    TBuf8<KUsbDescSize_Device> device;
-    const TInt r = Kern::ThreadDesRead(aThread, &aBuffer, device, 0);
-    if (r != KErrNone)
-        {
-        return r;
-        }
-    iDescriptors[KDescPosition_Device]->SetByte(2, device[2]); // bcdUSB
-    iDescriptors[KDescPosition_Device]->SetByte(3, device[3]); // bcdUSB (part II)
-    iDescriptors[KDescPosition_Device]->SetByte(4, device[4]); // bDeviceClass
-    iDescriptors[KDescPosition_Device]->SetByte(5, device[5]); // bDeviceSubClass
-    iDescriptors[KDescPosition_Device]->SetByte(6, device[6]); // bDeviceProtocol
-    iDescriptors[KDescPosition_Device]->SetByte(8, device[8]); // idVendor
-    iDescriptors[KDescPosition_Device]->SetByte(9, device[9]); // idVendor (part II)
-    iDescriptors[KDescPosition_Device]->SetByte(10, device[10]); // idProduct
-    iDescriptors[KDescPosition_Device]->SetByte(11, device[11]); // idProduct (part II)
-    iDescriptors[KDescPosition_Device]->SetByte(12, device[12]); // bcdDevice
-    iDescriptors[KDescPosition_Device]->SetByte(13, device[13]); // bcdDevice (part II)
-    return KErrNone;
-    }
-
-
-TInt TUsbcDescriptorPool::GetConfigurationDescriptorTC(DThread* aThread, TDes8& aBuffer) const
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::GetConfigurationDescriptorTC()"));
-    return Kern::ThreadDesWrite(aThread, &aBuffer, iDescriptors[KDescPosition_Config]->DescriptorData(), 0);
-    }
-
-
-TInt TUsbcDescriptorPool::SetConfigurationDescriptorTC(DThread* aThread, const TDes8& aBuffer)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::SetConfigurationDescriptorTC()"));
-    TBuf8<KUsbDescSize_Config> config;
-    const TInt r = Kern::ThreadDesRead(aThread, &aBuffer, config, 0);
-    if (r != KErrNone)
-        {
-        return r;
-        }
-    iDescriptors[KDescPosition_Config]->SetByte(7, config[7]); // bmAttributes
-    iDescriptors[KDescPosition_Config]->SetByte(8, config[8]); // bMaxPower
-    return KErrNone;
-    }
-
-
-TInt TUsbcDescriptorPool::GetOtgDescriptorTC(DThread* aThread, TDes8& aBuffer) const
-    {
-    return Kern::ThreadDesWrite(aThread, &aBuffer, iDescriptors[KDescPosition_Otg]->DescriptorData(), 0);
-    }
-
-
-TInt TUsbcDescriptorPool::SetOtgDescriptor(const TDesC8& aBuffer)
-    {
-    iDescriptors[KDescPosition_Otg]->SetByte(2, aBuffer[2]); // bmAttributes
-    return KErrNone;
-    }
-
-
-TInt TUsbcDescriptorPool::GetInterfaceDescriptorTC(DThread* aThread, TDes8& aBuffer,
-                                                   TInt aInterface, TInt aSetting) const
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::GetInterfaceDescriptorTC()"));
-    const TInt i = FindIfcDescriptor(aInterface, aSetting);
-    if (i < 0)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: no such interface"));
-        return KErrNotFound;
-        }
-    return Kern::ThreadDesWrite(aThread, &aBuffer, iDescriptors[i]->DescriptorData(), 0);
-    }
-
-
-TInt TUsbcDescriptorPool::SetInterfaceDescriptor(const TDes8& aBuffer, TInt aInterface, TInt aSetting)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::SetInterfaceDescriptor()"));
-    const TInt i = FindIfcDescriptor(aInterface, aSetting);
-    if (i < 0)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: no such interface"));
-        return KErrNotFound;
-        }
-    iDescriptors[i]->SetByte(2, aBuffer[2]);                // bInterfaceNumber
-    iDescriptors[i]->SetByte(5, aBuffer[5]);                // bInterfaceClass
-    iDescriptors[i]->SetByte(6, aBuffer[6]);                // bInterfaceSubClass
-    iDescriptors[i]->SetByte(7, aBuffer[7]);                // bInterfaceProtocol
-    return KErrNone;
-    }
-
-
-TInt TUsbcDescriptorPool::GetEndpointDescriptorTC(DThread* aThread, TDes8& aBuffer,
-                                                  TInt aInterface, TInt aSetting, TUint8 aEndpointAddress) const
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::GetEndpointDescriptorTC()"));
-    const TInt i = FindEpDescriptor(aInterface, aSetting, aEndpointAddress);
-    if (i < 0)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: no such endpoint"));
-        return KErrNotFound;
-        }
-    return Kern::ThreadDesWrite(aThread, &aBuffer, iDescriptors[i]->DescriptorData(), 0);
-    }
-
-
-TInt TUsbcDescriptorPool::SetEndpointDescriptorTC(DThread* aThread, const TDes8& aBuffer,
-                                                  TInt aInterface, TInt aSetting, TUint8 aEndpointAddress)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::SetEndpointDescriptorTC()"));
-    const TInt i = FindEpDescriptor(aInterface, aSetting, aEndpointAddress);
-    if (i < 0)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: no such endpoint"));
-        return KErrNotFound;
-        }
-    TBuf8<KUsbDescSize_AudioEndpoint> ep;                    // it could be an audio endpoint
-    const TInt r = Kern::ThreadDesRead(aThread, &aBuffer, ep, 0);
-    if (r != KErrNone)
-        {
-        return r;
-        }
-    iDescriptors[i]->SetByte(3, ep[3]);                        // bmAttributes
-    iDescriptors[i]->SetByte(6, ep[6]);                        // bInterval
-    if (iDescriptors[i]->Size() == KUsbDescSize_AudioEndpoint)
-        {
-        iDescriptors[i]->SetByte(7, ep[7]);                    // bRefresh
-        iDescriptors[i]->SetByte(8, ep[8]);                    // bSynchAddress
-        }
-    return KErrNone;
-    }
-
-
-TInt TUsbcDescriptorPool::GetEndpointDescriptorSize(TInt aInterface, TInt aSetting, TUint8 aEndpointAddress,
-                                                    TInt& aSize) const
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::GetEndpointDescriptorSize()"));
-    const TInt i = FindEpDescriptor(aInterface, aSetting, aEndpointAddress);
-    if (i < 0)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: no such endpoint"));
-        return KErrNotFound;
-        }
-    aSize = iDescriptors[i]->Size();
-    return KErrNone;
-    }
-
-
-TInt TUsbcDescriptorPool::GetDeviceQualifierDescriptorTC(DThread* aThread, TDes8& aBuffer) const
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::GetDeviceQualifierDescriptorTC()"));
-    if (iDescriptors[KDescPosition_DeviceQualifier] == NULL)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Warning: Device_Qualifier descriptor not supported"));
-        return KErrNotSupported;
-        }
-    return Kern::ThreadDesWrite(aThread, &aBuffer,
-                                iDescriptors[KDescPosition_DeviceQualifier]->DescriptorData(), 0);
-    }
-
-
-TInt TUsbcDescriptorPool::SetDeviceQualifierDescriptorTC(DThread* aThread, const TDes8& aBuffer)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::SetDeviceQualifierDescriptorTC()"));
-    if (iDescriptors[KDescPosition_DeviceQualifier] == NULL)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Warning: Device_Qualifier descriptor not supported"));
-        return KErrNotSupported;
-        }
-    TBuf8<KUsbDescSize_DeviceQualifier> device;
-    const TInt r = Kern::ThreadDesRead(aThread, &aBuffer, device, 0);
-    if (r != KErrNone)
-        {
-        return r;
-        }
-    iDescriptors[KDescPosition_DeviceQualifier]->SetByte(2, device[2]); // bcdUSB
-    iDescriptors[KDescPosition_DeviceQualifier]->SetByte(3, device[3]); // bcdUSB (part II)
-    iDescriptors[KDescPosition_DeviceQualifier]->SetByte(4, device[4]); // bDeviceClass
-    iDescriptors[KDescPosition_DeviceQualifier]->SetByte(5, device[5]); // bDeviceSubClass
-    iDescriptors[KDescPosition_DeviceQualifier]->SetByte(6, device[6]); // bDeviceProtocol
-    return KErrNone;
-    }
-
-
-TInt TUsbcDescriptorPool::GetOtherSpeedConfigurationDescriptorTC(DThread* aThread, TDes8& aBuffer) const
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::GetOtherSpeedConfigurationDescriptorTC()"));
-    if (iDescriptors[KDescPosition_OtherSpeedConfig] == NULL)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Warning: Other_Speed_Configuration descriptor not supported"));
-        return KErrNotSupported;
-        }
-    return Kern::ThreadDesWrite(aThread, &aBuffer,
-                                iDescriptors[KDescPosition_OtherSpeedConfig]->DescriptorData(), 0);
-    }
-
-
-TInt TUsbcDescriptorPool::SetOtherSpeedConfigurationDescriptorTC(DThread* aThread, const TDes8& aBuffer)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::SetOtherSpeedConfigurationDescriptorTC()"));
-    if (iDescriptors[KDescPosition_OtherSpeedConfig] == NULL)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Warning: Other_Speed_Configuration descriptor not supported"));
-        return KErrNotSupported;
-        }
-    TBuf8<KUsbDescSize_OtherSpeedConfig> config;
-    const TInt r = Kern::ThreadDesRead(aThread, &aBuffer, config, 0);
-    if (r != KErrNone)
-        {
-        return r;
-        }
-    iDescriptors[KDescPosition_OtherSpeedConfig]->SetByte(7, config[7]); // bmAttributes
-    iDescriptors[KDescPosition_OtherSpeedConfig]->SetByte(8, config[8]); // bMaxPower
-    return KErrNone;
-    }
-
-
-TInt TUsbcDescriptorPool::GetCSInterfaceDescriptorTC(DThread* aThread, TDes8& aBuffer,
-                                                     TInt aInterface, TInt aSetting) const
-    {
-    // first find the interface
-    TInt i = FindIfcDescriptor(aInterface, aSetting);
-    if (i < 0)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: no such interface"));
-        return KErrNotFound;
-        }
-    TInt r = KErrNotFound;
-    TInt offset = 0;
-    const TInt count = iDescriptors.Count();
-    while (++i < count && iDescriptors[i]->Type() == KUsbDescType_CS_Interface)
-        {
-        r = Kern::ThreadDesWrite(aThread, &aBuffer,
-                                 iDescriptors[i]->DescriptorData(), offset);
-        if (r != KErrNone)
-            break;
-        offset += iDescriptors[i]->Size();
-        }
-    return r;
-    }
-
-
-TInt TUsbcDescriptorPool::SetCSInterfaceDescriptorTC(DThread* aThread, const TDes8& aBuffer,
-                                                     TInt aInterface, TInt aSetting, TInt aSize)
-    {
-    // First find the interface
-    TInt i = FindIfcDescriptor(aInterface, aSetting);
-    if (i < 0)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: no such interface"));
-        return KErrNotFound;
-        }
-    // Find a position where to insert the new class specific interface descriptor(s)
-    const TInt count = iDescriptors.Count();
-    while (++i < count && iDescriptors[i]->Type() == KUsbDescType_CS_Interface)
-        ;
-    // Create a new cs descriptor
-    TUsbcClassSpecificDescriptor* desc = TUsbcClassSpecificDescriptor::New(KUsbDescType_CS_Interface, aSize);
-    if (!desc)
-        {
-        return KErrNoMemory;
-        }
-    __KTRACE_OPT(KUSB, Kern::Printf("  inserting descriptor at position %d", i));
-    iDescriptors.Insert(desc, i);
-
-    // Update the config descriptor's wTotalLength field
-    UpdateConfigDescriptorLength(aSize);
-
-    // Copy contents from the user side
-    return Kern::ThreadDesRead(aThread, &aBuffer, iDescriptors[i]->DescriptorData(), 0);
-    }
-
-
-TInt TUsbcDescriptorPool::GetCSInterfaceDescriptorSize(TInt aInterface, TInt aSetting, TInt& aSize) const
-    {
-    // first find the interface
-    TInt i = FindIfcDescriptor(aInterface, aSetting);
-    if (i < 0)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: no such interface"));
-        return KErrNotFound;
-        }
-    TInt r = KErrNotFound;
-    TInt size = 0;
-    const TInt count = iDescriptors.Count();
-    while (++i < count && iDescriptors[i]->Type() == KUsbDescType_CS_Interface)
-        {
-        size += iDescriptors[i]->Size();
-        r = KErrNone;
-        }
-    if (r == KErrNone)
-        aSize = size;
-    return r;
-    }
-
-
-TInt TUsbcDescriptorPool::GetCSEndpointDescriptorTC(DThread* aThread, TDes8& aBuffer, TInt aInterface,
-                                                    TInt aSetting, TUint8 aEndpointAddress) const
-    {
-    // first find the endpoint
-    TInt i = FindEpDescriptor(aInterface, aSetting, aEndpointAddress);
-    if (i < 0)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: no such endpoint"));
-        return KErrNotFound;
-        }
-    TInt r = KErrNotFound;
-    TInt offset = 0;
-    const TInt count = iDescriptors.Count();
-    while (++i < count && iDescriptors[i]->Type() == KUsbDescType_CS_Endpoint)
-        {
-        r = Kern::ThreadDesWrite(aThread, &aBuffer,
-                                 iDescriptors[i]->DescriptorData(), offset);
-        if (r != KErrNone)
-            break;
-        offset += iDescriptors[i]->Size();
-        }
-    return r;
-    }
-
-
-TInt TUsbcDescriptorPool::SetCSEndpointDescriptorTC(DThread* aThread, const TDes8& aBuffer, TInt aInterface,
-                                                    TInt aSetting, TUint8 aEndpointAddress, TInt aSize)
-    {
-    // first find the endpoint
-    TInt i = FindEpDescriptor(aInterface, aSetting, aEndpointAddress);
-    if (i < 0)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: no such endpoint"));
-        return KErrNotFound;
-        }
-    // find a position where to insert the new class specific endpoint descriptor(s)
-    const TInt count = iDescriptors.Count();
-    while (++i < count && iDescriptors[i]->Type() == KUsbDescType_CS_Endpoint)
-        ;
-    // create a new cs descriptor
-    TUsbcClassSpecificDescriptor* desc = TUsbcClassSpecificDescriptor::New(KUsbDescType_CS_Endpoint, aSize);
-    if (!desc)
-        {
-        return KErrNoMemory;
-        }
-    iDescriptors.Insert(desc, i);
-    // update the config descriptor's wTotalLength field
-    UpdateConfigDescriptorLength(aSize);
-    // copy contents from user side
-    return Kern::ThreadDesRead(aThread, &aBuffer, iDescriptors[i]->DescriptorData(), 0);
-    }
-
-
-TInt TUsbcDescriptorPool::GetCSEndpointDescriptorSize(TInt aInterface, TInt aSetting,
-                                                      TUint8 aEndpointAddress, TInt& aSize) const
-    {
-    // first find the endpoint
-    TInt i = FindEpDescriptor(aInterface, aSetting, aEndpointAddress);
-    if (i < 0)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: no such endpoint"));
-        return KErrNotFound;
-        }
-    TInt r = KErrNotFound;
-    TInt size = 0;
-    const TInt count = iDescriptors.Count();
-    while (++i < count && iDescriptors[i]->Type() == KUsbDescType_CS_Endpoint)
-        {
-        size += iDescriptors[i]->Size();
-        r = KErrNone;
-        }
-    if (r == KErrNone)
-        aSize = size;
-    return r;
-    }
-
-
-TInt TUsbcDescriptorPool::GetStringDescriptorLangIdTC(DThread* aThread, TDes8& aLangId) const
-    {
-    const TUint16 id = iStrings[KStringPosition_Langid]->Word(2);
-    const TPtrC8 id_des(reinterpret_cast<const TUint8*>(&id), sizeof(id));
-    return Kern::ThreadDesWrite(aThread, &aLangId, id_des, 0);
-    }
-
-
-TInt TUsbcDescriptorPool::SetStringDescriptorLangId(TUint16 aLangId)
-    {
-    iStrings[KStringPosition_Langid]->SetWord(2, aLangId);
-    return KErrNone;
-    }
-
-
-TInt TUsbcDescriptorPool::GetManufacturerStringDescriptorTC(DThread* aThread, TDes8& aString) const
-    {
-    return GetDeviceStringDescriptorTC(aThread, aString, KUsbDescStringIndex_Manufact,
-                                       KStringPosition_Manufact);
-    }
-
-
-TInt TUsbcDescriptorPool::SetManufacturerStringDescriptorTC(DThread* aThread, const TDes8& aString)
-    {
-    return SetDeviceStringDescriptorTC(aThread, aString, KUsbDescStringIndex_Manufact,
-                                       KStringPosition_Manufact);
-    }
-
-
-TInt TUsbcDescriptorPool::RemoveManufacturerStringDescriptor()
-    {
-    return RemoveDeviceStringDescriptor(KUsbDescStringIndex_Manufact, KStringPosition_Manufact);
-    }
-
-
-TInt TUsbcDescriptorPool::GetProductStringDescriptorTC(DThread* aThread, TDes8& aString) const
-    {
-    return GetDeviceStringDescriptorTC(aThread, aString, KUsbDescStringIndex_Product,
-                                       KStringPosition_Product);
-    }
-
-
-TInt TUsbcDescriptorPool::SetProductStringDescriptorTC(DThread* aThread, const TDes8& aString)
-    {
-    return SetDeviceStringDescriptorTC(aThread, aString, KUsbDescStringIndex_Product,
-                                       KStringPosition_Product);
-    }
-
-
-TInt TUsbcDescriptorPool::RemoveProductStringDescriptor()
-    {
-    return RemoveDeviceStringDescriptor(KUsbDescStringIndex_Product, KStringPosition_Product);
-    }
-
-
-TInt TUsbcDescriptorPool::GetSerialNumberStringDescriptorTC(DThread* aThread, TDes8& aString) const
-    {
-    return GetDeviceStringDescriptorTC(aThread, aString, KUsbDescStringIndex_Serial,
-                                       KStringPosition_Serial);
-    }
-
-
-TInt TUsbcDescriptorPool::SetSerialNumberStringDescriptorTC(DThread* aThread, const TDes8& aString)
-    {
-    return SetDeviceStringDescriptorTC(aThread, aString, KUsbDescStringIndex_Serial,
-                                       KStringPosition_Serial);
-    }
-
-
-TInt TUsbcDescriptorPool::RemoveSerialNumberStringDescriptor()
-    {
-    return RemoveDeviceStringDescriptor(KUsbDescStringIndex_Serial, KStringPosition_Serial);
-    }
-
-
-TInt TUsbcDescriptorPool::GetConfigurationStringDescriptorTC(DThread* aThread, TDes8& aString) const
-    {
-    const TInt str_idx = iDescriptors[KDescPosition_Config]->Byte(KUsbDescStringIndex_Config);
-    if (str_idx)
-        {
-        __ASSERT_ALWAYS((str_idx == KStringPosition_Config), Kern::Fault(KUsbPanicCat, __LINE__));
-        __KTRACE_OPT(KUSB, Kern::Printf("  String @ pos %d (conf $): \"%S\"",
-                                        str_idx, &iStrings[str_idx]->StringData()));
-        return Kern::ThreadDesWrite(aThread, &aString,
-                                    iStrings[str_idx]->StringData(), 0);
-        }
-    else
-        {
-        __KTRACE_OPT(KUSB, Kern::Printf("  No config string descriptor @ pos %d", str_idx));
-        return KErrNotFound;
-        }
-    }
-
-
-TInt TUsbcDescriptorPool::SetConfigurationStringDescriptorTC(DThread* aThread, const TDes8& aString)
-    {
-    // we don't know the length of the string, so we have to allocate memory dynamically
-    TUint strlen = Kern::ThreadGetDesLength(aThread, &aString);
-    if (strlen > KUsbStringDescStringMaxSize)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Warning: config $ descriptor too long - will be truncated"));
-        strlen = KUsbStringDescStringMaxSize;
-        }
-    HBuf8* const strbuf = HBuf8::New(strlen);
-    if (!strbuf)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for config $ desc string failed (1)"));
-        return KErrNoMemory;
-        }
-    strbuf->SetMax();
-    // the aString points to data that lives in user memory, so we have to copy it:
-    const TInt r = Kern::ThreadDesRead(aThread, &aString, *strbuf, 0);
-    if (r != KErrNone)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Thread read error"));
-        delete strbuf;
-        return r;
-        }
-    TUsbcStringDescriptor* sd = TUsbcStringDescriptor::New(*strbuf);
-    if (!sd)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for config $ desc failed (2)"));
-        delete strbuf;
-        return KErrNoMemory;
-        }
-    // Delete old string, put in new one
-    ExchangeStringDescriptor(KStringPosition_Config, sd);
-    // Update Config descriptor string index field
-    iDescriptors[KDescPosition_Config]->SetByte(KUsbDescStringIndex_Config, KStringPosition_Config);
-    // Update Other_Speed_Config descriptor string index field as well, if applicable
-    if (iDescriptors[KDescPosition_OtherSpeedConfig])
-        iDescriptors[KDescPosition_OtherSpeedConfig]->SetByte(KUsbDescStringIndex_Config,
-                                                              KStringPosition_Config);
-    delete strbuf;
-    return KErrNone;
-    }
-
-
-TInt TUsbcDescriptorPool::RemoveConfigurationStringDescriptor()
-    {
-    if (iDescriptors[KDescPosition_Config]->Byte(KUsbDescStringIndex_Config) == 0)
-        {
-        __KTRACE_OPT(KUSB, Kern::Printf("  RemoveConfigurationStringDescriptor: no $ desc @ index %d",
-                                        KUsbDescStringIndex_Config));
-        return KErrNotFound;
-        }
-    // Delete old string, put in NULL pointer
-    ExchangeStringDescriptor(KStringPosition_Config, NULL);
-    // Update Config descriptor string index field
-    iDescriptors[KDescPosition_Config]->SetByte(KUsbDescStringIndex_Config, 0);
-    // Update Other_Speed_Config descriptor string index field as well, if applicable
-    if (iDescriptors[KDescPosition_OtherSpeedConfig])
-        iDescriptors[KDescPosition_OtherSpeedConfig]->SetByte(KUsbDescStringIndex_Config, 0);
-    return KErrNone;
-    }
-
-
-TInt TUsbcDescriptorPool::GetStringDescriptorTC(DThread* aThread, TInt aIndex, TDes8& aString) const
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::GetStringDescriptorTC()"));
-    if (!StringDescriptorExists(aIndex))
-        {
-        return KErrNotFound;
-        }
-    __KTRACE_OPT(KUSB, Kern::Printf("  String @ pos %d: \"%S\"",
-                                    aIndex, &iStrings[aIndex]->StringData()));
-    return Kern::ThreadDesWrite(aThread, &aString, iStrings[aIndex]->StringData(), 0);
-    }
-
-
-TInt TUsbcDescriptorPool::SetStringDescriptorTC(DThread* aThread, TInt aIndex, const TDes8& aString)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::SetStringDescriptorTC()"));
-    // we don't know the length of the string, so we have to allocate memory dynamically
-    TUint strlen = Kern::ThreadGetDesLength(aThread, &aString);
-    if (strlen > KUsbStringDescStringMaxSize)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Warning: $ descriptor too long - will be truncated"));
-        strlen = KUsbStringDescStringMaxSize;
-        }
-    HBuf8* strbuf = HBuf8::New(strlen);
-    if (!strbuf)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Mem alloc for $ desc string failed (1)"));
-        return KErrNoMemory;
-        }
-    strbuf->SetMax();
-    // the aString points to data that lives in user memory, so we have to copy it over:
-    const TInt r = Kern::ThreadDesRead(aThread, &aString, *strbuf, 0);
-    if (r != KErrNone)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Thread read error"));
-        delete strbuf;
-        return r;
-        }
-    TUsbcStringDescriptor* const sd = TUsbcStringDescriptor::New(*strbuf);
-    if (!sd)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Mem alloc for $ desc failed (2)"));
-        delete strbuf;
-        return KErrNoMemory;
-        }
-    if (aIndex < iStrings.Count())
-        {
-        ExchangeStringDescriptor(aIndex, sd);
-        }
-    else // if (aIndex >= iStrings.Count())
-        {
-        while (aIndex > iStrings.Count())
-            {
-            iStrings.Append(NULL);
-            }
-        iStrings.Append(sd);
-        }
-    delete strbuf;
-    return KErrNone;
-    }
-
-
-TInt TUsbcDescriptorPool::RemoveStringDescriptor(TInt aIndex)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::RemoveStringDescriptor()"));
-    if (!StringDescriptorExists(aIndex))
-        {
-        return KErrNotFound;
-        }
-    __KTRACE_OPT(KUSB, Kern::Printf("  Removing string @ pos %d: \"%S\"",
-                                    aIndex, &iStrings[aIndex]->StringData()));
-    ExchangeStringDescriptor(aIndex, NULL);
-
-    // Make sure there's no $ after aIndex.
-    const TInt n = iStrings.Count();
-    for (TInt i = aIndex; i < n; i++)
-        {
-        if (iStrings[i] != NULL)
-            {
-            __KTRACE_OPT(KUSB, Kern::Printf("  Found $ @ idx %d - not compressing", i));
-            return KErrNone;
-            }
-        }
-
-    __KTRACE_OPT(KUSB, Kern::Printf("  No $ found after idx %d - compressing array", aIndex));
-    // Move aIndex back just before the first !NULL element.
-    while (iStrings[--aIndex] == NULL)
-        ;
-    // Let aIndex point to first NULL.
-    aIndex++;
-    __KTRACE_OPT(KUSB, Kern::Printf("  Starting at index %d", aIndex));
-    // Now remove NULL pointers until (Count() == aIndex).
-    __KTRACE_OPT(KUSB, Kern::Printf("  iStrings.Count() before: %d", iStrings.Count()));
-    do
-        {
-        iStrings.Remove(aIndex);
-        __KTRACE_OPT(KUSB, Kern::Printf("  Removing $"));
-        }
-    while (iStrings.Count() > aIndex);
-    __KTRACE_OPT(KUSB, Kern::Printf("  iStrings.Count() after: %d", iStrings.Count()));
-
-    // Regain some memory.
-    iStrings.Compress();
-
-    return KErrNone;
-    }
-
-
-// ===================================================================
-// --- private ---
-// ===================================================================
-
-//
-// Insert an Interface descriptor into the descriptor array at the appropriate index.
-//
-void TUsbcDescriptorPool::InsertIfcDesc(TUsbcDescriptorBase* aDesc)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::InsertIfcDesc()"));
-
-    const TInt count = iDescriptors.Count();
-    TBool ifc_exists = EFalse;                                // set to 'true' if we're adding an alternate
-                                                            // setting to an already existing interface
-    TInt i = KDescPosition_FirstAvailable;
-    while (i < count)
-        {
-        __KTRACE_OPT(KUSB, Kern::Printf("  already descriptors there (%d)...", count));
-        if (iDescriptors[i]->Type() == KUsbDescType_Interface)
-            {
-            if (iDescriptors[i]->Byte(2) > aDesc->Byte(2))
-                {
-                // our interface number is less than the one's just found => insert before it (= here)
-                break;
-                }
-            else if (iDescriptors[i]->Byte(2) == aDesc->Byte(2))
-                {
-                ifc_exists = ETrue;
-                // same interface number => look at settings number
-                if (iDescriptors[i]->Byte(3) > aDesc->Byte(3))
-                    {
-                    // our setting number is less than the one's found => insert before (= here)
-                    break;
-                    }
-                else if (iDescriptors[i]->Byte(3) == aDesc->Byte(3))
-                    {
-                    __KTRACE_OPT(KPANIC, Kern::Printf("  Error: first delete old desc "
-                                                      "(TUsbcDescriptorPool::InsertIfcDesc)"));
-                    return;
-                    }
-                }
-            }
-        ++i;
-        }
-    // In any case: put the new descriptor at position i.
-    __KTRACE_OPT(KUSB, Kern::Printf("  inserting descriptor at position %d", i));
-    iDescriptors.Insert(aDesc, i);
-
-    // Update the config descriptor's wTotalLength field.
-    UpdateConfigDescriptorLength(KUsbDescSize_Interface);
-
-    if (!ifc_exists)
-        {
-        // If this is the first setting for the interface, increment bNumInterfaces.
-        UpdateConfigDescriptorNumIfcs(1);
-        }
-
-    iIfcIdx = i;
-    }
-
-
-//
-// Insert an Endpoint descriptor into the descriptor array at the appropriate index.
-//
-void TUsbcDescriptorPool::InsertEpDesc(TUsbcDescriptorBase* aDesc)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::InsertEpDesc()"));
-    if (iIfcIdx == 0)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: only after interface "
-                                          "(TUsbcDescriptorPool::InsertEpDesc)"));
-        return;
-        }
-    const TInt count = iDescriptors.Count();
-    TInt i = iIfcIdx + 1;
-    while (i < count)
-        {
-        if (iDescriptors[i]->Type() != KUsbDescType_Endpoint)
-            break;
-        ++i;
-        }
-    // put the new descriptor at position i
-    iDescriptors.Insert(aDesc, i);
-    // update the config descriptor's wTotalLength field
-    UpdateConfigDescriptorLength(aDesc->Size());
-    }
-
-
-//
-// Find the index of the Interface descriptor for a given interface setting.
-//
-TInt TUsbcDescriptorPool::FindIfcDescriptor(TInt aIfcNumber, TInt aIfcSetting) const
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::FindIfcDescriptor(%d, %d)",
-                                    aIfcNumber, aIfcSetting));
-    const TInt count = iDescriptors.Count();
-    for (TInt i = KDescPosition_FirstAvailable; i < count; i++)
-        {
-        if ((iDescriptors[i]->Type() == KUsbDescType_Interface) &&
-            (iDescriptors[i]->Byte(2) == aIfcNumber) &&
-            (iDescriptors[i]->Byte(3) == aIfcSetting))
-            {
-            return i;
-            }
-        }
-    __KTRACE_OPT(KPANIC, Kern::Printf("  Error: no such interface"));
-    return -1;
-    }
-
-
-//
-// Find the index of the Endpoint descriptor for a given endpoint on a given interface setting.
-//
-TInt TUsbcDescriptorPool::FindEpDescriptor(TInt aIfcNumber, TInt aIfcSetting, TUint8 aEpAddress) const
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::FindEpDescriptor(%d, %d, 0x%02x)",
-                                    aIfcNumber, aIfcSetting, aEpAddress));
-    // first find the interface
-    const TInt ifc = FindIfcDescriptor(aIfcNumber, aIfcSetting);
-    if (ifc < 0)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: no such interface"));
-        return ifc;
-        }
-    const TInt count = iDescriptors.Count();
-    // then, before the next interface, try to locate the endpoint
-    for (TInt i = ifc + 1; i < count; i++)
-        {
-        if (iDescriptors[i]->Type() == KUsbDescType_Interface)
-            {
-            __KTRACE_OPT(KPANIC, Kern::Printf("  Error: no such endpoint before next interface"));
-            return -1;
-            }
-        else if ((iDescriptors[i]->Type() == KUsbDescType_Endpoint) &&
-                 (iDescriptors[i]->Byte(2) == aEpAddress))
-            {
-            // found
-            return i;
-            }
-        }
-    __KTRACE_OPT(KPANIC, Kern::Printf("  Error: no such endpoint"));
-    return -1;
-    }
-
-
-//
-// Delete n descriptors starting from aIndex and remove their pointers from the array.
-//
-void TUsbcDescriptorPool::DeleteDescriptors(TInt aIndex, TInt aCount)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::DeleteDescriptors()"));
-    if (aIndex < KDescPosition_FirstAvailable)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: aIndex < KDescPosition_FirstAvailable"));
-        return;
-        }
-    if (aCount <= 0)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: aCount <= 0"));
-        return;
-        }
-    __KTRACE_OPT(KUSB, Kern::Printf("  Removing descriptors at index %d:", aIndex));
-    // Try to update wTotalLength field in Config descriptor
-    while (aCount--)
-        {
-        // In this loop we don't decrement aIndex, because after deleting an element
-        // aIndex is already indexing the next one.
-        TUsbcDescriptorBase* const ptr = iDescriptors[aIndex];
-        switch (ptr->Type())
-            {
-        case KUsbDescType_Interface:
-            __KTRACE_OPT(KUSB, Kern::Printf("  - an interface descriptor"));
-            UpdateConfigDescriptorLength(-KUsbDescSize_Interface);
-            break;
-        case KUsbDescType_Endpoint:
-            __KTRACE_OPT(KUSB, Kern::Printf("  - an endpoint descriptor"));
-            UpdateConfigDescriptorLength(-ptr->Size());
-            break;
-        case KUsbDescType_CS_Interface:
-            /* fall through */
-        case KUsbDescType_CS_Endpoint:
-            __KTRACE_OPT(KUSB, Kern::Printf("  - a class specific descriptor"));
-            UpdateConfigDescriptorLength(-ptr->Size());
-            break;
-        default:
-            __KTRACE_OPT(KUSB, Kern::Printf("  - an unknown descriptor"));
-            __KTRACE_OPT(KPANIC, Kern::Printf("  Error: unknown descriptor type"));
-            }
-        iDescriptors.Remove(aIndex);
-        delete ptr;
-        }
-    }
-
-
-//
-// Update the wTotalLength field in the Configuration descriptor (aLength can be negative).
-//
-void TUsbcDescriptorPool::UpdateConfigDescriptorLength(TInt aLength)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::UpdateConfigDescriptorLength(%d)", aLength));
-    TUsbcDescriptorBase* const cnf = iDescriptors[KDescPosition_Config];
-    __KTRACE_OPT(KUSB, Kern::Printf("  wTotalLength old: %d", cnf->Word(2)));
-    // Update Config descriptor
-    cnf->SetWord(2, cnf->Word(2) + aLength);
-    __KTRACE_OPT(KUSB, Kern::Printf("  wTotalLength new: %d", cnf->Word(2)));
-    // Update Other_Speed_Config descriptor as well, if applicable
-    if (iDescriptors[KDescPosition_OtherSpeedConfig])
-        iDescriptors[KDescPosition_OtherSpeedConfig]->SetWord(2, cnf->Word(2));
-    }
-
-
-//
-// Update the bNumInterfaces field in the Configuration descriptor (aNumber can be negative).
-//
-void TUsbcDescriptorPool::UpdateConfigDescriptorNumIfcs(TInt aNumber)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::UpdateConfigDescriptorNumIfcs(%d)", aNumber));
-    TUsbcDescriptorBase* const cnf = iDescriptors[KDescPosition_Config];
-    __KTRACE_OPT(KUSB, Kern::Printf("  bNumInterfaces old: %d", cnf->Byte(4)));
-    const TInt n = cnf->Byte(4) + aNumber;
-    if (n < 0)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: bNumInterfaces + aNumber < 0"));
-        return;
-        }
-    // Update Config descriptor
-    cnf->SetByte(4, n);
-    __KTRACE_OPT(KUSB, Kern::Printf("  bNumInterfaces new: %d", cnf->Byte(4)));
-    // Update Other_Speed_Config descriptor as well, if applicable
-    if (iDescriptors[KDescPosition_OtherSpeedConfig])
-        iDescriptors[KDescPosition_OtherSpeedConfig]->SetByte(4, n);
-    }
-
-
-//
-// Update the bNumInterfaces field in the Configuration descriptor if necessary.
-//
-void TUsbcDescriptorPool::UpdateIfcNumbers(TInt aNumber)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::UpdateIfcNumbers(%d)", aNumber));
-    const TInt count = iDescriptors.Count();
-    for (TInt i = KDescPosition_FirstAvailable; i < count; i++)
-        {
-        if ((iDescriptors[i]->Type() == KUsbDescType_Interface) &&
-            (iDescriptors[i]->Byte(2) == aNumber))
-            {
-            // there's still an interface with 'number' so we don't need to update anything
-            return;
-            }
-        }
-    // if we haven't returned yet, we decrement bNumInterfaces
-    UpdateConfigDescriptorNumIfcs(-1);
-    }
-
-
-//
-// Put the current Device or Device_Qualifier descriptor in the Ep0 Tx buffer.
-// Only used for Ep0 standard requests, so target buffer can be hard-wired.
-//
-TInt TUsbcDescriptorPool::GetDeviceDescriptor(TInt aIndex) const
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::GetDeviceDescriptor()"));
-    __ASSERT_DEBUG((aIndex == KDescPosition_Device) || (aIndex == KDescPosition_DeviceQualifier),
-                   Kern::Printf("  Error: invalid descriptor index: %d", aIndex));
-    if (iDescriptors[aIndex] == NULL)
-        {
-        // This doesn't have to be an error - we might get asked here for the Device_Qualifier descriptor
-        // on a FS-only device.
-        __KTRACE_OPT(KUSB, Kern::Printf("  Descriptor #%d requested but not available", aIndex));
-        return 0;
-        }
-    return iDescriptors[aIndex]->GetDescriptorData(iEp0_TxBuf, KUsbcBufSz_Ep0Tx);
-    }
-
-
-//
-// Put the current Configuration or Other_Speed_Configuration descriptor + all the following
-// descriptors in the Ep0 Tx buffer.
-// Only used for Ep0 standard requests, so target buffer can be hard-wired.
-//
-TInt TUsbcDescriptorPool::GetConfigurationDescriptor(TInt aIndex) const
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::GetConfigDescriptor(%d)", aIndex));
-    __ASSERT_DEBUG((aIndex == KDescPosition_Config) || (aIndex == KDescPosition_OtherSpeedConfig),
-                   Kern::Printf("  Error: invalid descriptor index: %d", aIndex));
-    if (iDescriptors[aIndex] == NULL)
-        {
-        // This is always an error: We should always have a Configuration descriptor and we should never
-        // get asked for the Other_Speed_Configuration descriptor if we don't have one (9.6.2).
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Warning: Descriptor %d requested but not available", aIndex));
-        return 0;
-        }
-    const TInt count = iDescriptors.Count();
-    TInt copied = 0;
-    TUint8* buf = iEp0_TxBuf;
-    for (TInt i = aIndex; i < count; i++)
-        {
-        TUsbcDescriptorBase* const ptr = iDescriptors[i];
-        if ((aIndex == KDescPosition_OtherSpeedConfig) && (i == KDescPosition_Config))
-            {
-            // Skip Config descriptor when returning Other_Speed_Config
-            continue;
-            }
-        if ((i == KDescPosition_Otg) && (iDescriptors[i] == NULL))
-            {
-            __KTRACE_OPT(KUSB, Kern::Printf("  no OTG descriptor -> next"));
-            continue;
-            }
-        // We need to edit endpoint descriptors on the fly because we have only one copy
-        // of each and that copy has to contain different information, depending on the
-        // current speed and the type of descriptor requested.
-        if (ptr->Type() == KUsbDescType_Endpoint)
-            {
-            if ((iHighSpeed && (aIndex == KDescPosition_Config)) ||
-                (!iHighSpeed && (aIndex == KDescPosition_OtherSpeedConfig)))
-                {
-                ptr->UpdateHs();
-                }
-            else
-                {
-                ptr->UpdateFs();
-                }
-            }
-        __KTRACE_OPT(KUSB, Kern::Printf("  desc[%02d]: type = 0x%02x size = %d ",
-                                        i, ptr->Type(), ptr->Size()));
-        const TInt size = ptr->GetDescriptorData(buf, KUsbcBufSz_Ep0Tx - copied);
-        if (size == 0)
-            {
-            __KTRACE_OPT(KPANIC,
-                         Kern::Printf("  Error: No Tx buffer space to copy this descriptor -> exiting"));
-            break;
-            }
-        copied += size;
-        if (copied >= KUsbcBufSz_Ep0Tx)
-            {
-            __KTRACE_OPT(KPANIC,
-                         Kern::Printf("  Error: No Tx buffer space left -> stopping here"));
-            break;
-            }
-        buf += size;
-        }
-    __KTRACE_OPT(KUSB, Kern::Printf("  copied %d bytes", copied));
-    return copied;
-    }
-
-
-//
-// Put the current OTG descriptor in the Ep0 Tx buffer.
-// Only used for Ep0 standard requests, so target buffer can be hard-wired.
-//
-TInt TUsbcDescriptorPool::GetOtgDescriptor() const
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::GetOtgDescriptor()"));
-    if (iDescriptors[KDescPosition_Otg] == NULL)
-        {
-        __KTRACE_OPT(KUSB, Kern::Printf("  OTG Descriptor not set"));
-        return 0;
-        }
-    return iDescriptors[KDescPosition_Otg]->GetDescriptorData(iEp0_TxBuf, KUsbcBufSz_Ep0Tx);
-    }
-
-
-//
-// Put a specific String descriptor in the Ep0 Tx buffer.
-// Only used for Ep0 standard requests, so target buffer can be hard-wired.
-//
-TInt TUsbcDescriptorPool::GetStringDescriptor(TInt aIndex) const
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::GetStringDescriptor(%d)", aIndex));
-    // I really would have liked to display the descriptor contents here, but without trailing zero
-    // we got a problem: how can we tell printf where the string ends? We would have to
-    // dynamically allocate memory (since we don't know the size in advance), copy the descriptor
-    // contents there, append a zero, and give this to printf. That's a bit too much effort...
-    if (!StringDescriptorExists(aIndex))
-        {
-        return 0;
-        }
-    return iStrings[aIndex]->GetDescriptorData(iEp0_TxBuf, KUsbcBufSz_Ep0Tx);
-    }
-
-
-//
-// Write a String descriptor pointed to by the Device descriptor to the user side
-// (one of Manufacturer, Product, SerialNumber).
-//
-TInt TUsbcDescriptorPool::GetDeviceStringDescriptorTC(DThread* aThread, TDes8& aString,
-                                                      TInt aIndex, TInt aPosition) const
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::GetDeviceStringDescriptorTC()"));
-    const TInt str_idx = iDescriptors[KDescPosition_Device]->Byte(aIndex);
-    if (str_idx)
-        {
-        __ASSERT_ALWAYS((str_idx == aPosition), Kern::Fault(KUsbPanicCat, __LINE__));
-        __KTRACE_OPT(KUSB, Kern::Printf("  String @ pos %d (device $): \"%S\"",
-                                        str_idx, &iStrings[str_idx]->StringData()));
-        return Kern::ThreadDesWrite(aThread, &aString,
-                                    iStrings[str_idx]->StringData(), 0);
-        }
-    else
-        {
-        __KTRACE_OPT(KUSB, Kern::Printf("  No string descriptor @ pos %d", aIndex));
-        return KErrNotFound;
-        }
-    }
-
-
-//
-// Read a Device String descriptor from the user side and put in the descriptor arrays
-// (one of Manufacturer, Product, SerialNumber).
-//
-TInt TUsbcDescriptorPool::SetDeviceStringDescriptorTC(DThread* aThread, const TDes8& aString,
-                                                      TInt aIndex, TInt aPosition)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::SetDeviceStringDescriptorTC()"));
-    // we don't know the length of the string, so we have to allocate memory dynamically
-    TUint strlen = Kern::ThreadGetDesLength(aThread, &aString);
-    if (strlen > KUsbStringDescStringMaxSize)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Warning: $ descriptor too long - will be truncated"));
-        strlen = KUsbStringDescStringMaxSize;
-        }
-    HBuf8* const strbuf = HBuf8::New(strlen);
-    if (!strbuf)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for dev $ desc string failed (1)"));
-        return KErrNoMemory;
-        }
-    strbuf->SetMax();
-    // the aString points to data that lives in user memory, so we have to copy it:
-    const TInt r = Kern::ThreadDesRead(aThread, &aString, *strbuf, 0);
-    if (r != KErrNone)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Thread read error"));
-        delete strbuf;
-        return r;
-        }
-    TUsbcStringDescriptor* const sd = TUsbcStringDescriptor::New(*strbuf);
-    if (!sd)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for dev $ desc failed (2)"));
-        delete strbuf;
-        return KErrNoMemory;
-        }
-    ExchangeStringDescriptor(aPosition, sd);
-    iDescriptors[KDescPosition_Device]->SetByte(aIndex, aPosition);
-    delete strbuf;
-    return r;
-    }
-
-
-//
-// Remove a Device String descriptor from the descriptor arrays
-// (one of Manufacturer, Product, SerialNumber).
-//
-TInt TUsbcDescriptorPool::RemoveDeviceStringDescriptor(TInt aIndex, TInt aPosition)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::RemoveDeviceStringDescriptor()"));
-    if (iDescriptors[KDescPosition_Device]->Byte(aIndex) == 0)
-        {
-        __KTRACE_OPT(KUSB, Kern::Printf("  RemoveDeviceStringDescriptor: no $ desc @ index %d", aIndex));
-        return KErrNotFound;
-        }
-    ExchangeStringDescriptor(aPosition, NULL);
-    iDescriptors[KDescPosition_Device]->SetByte(aIndex, 0);
-    return KErrNone;
-    }
-
-
-//
-// Puts aDesc at postion aIndex in the string descriptor array, after deleting what was (possibly) there.
-//
-void TUsbcDescriptorPool::ExchangeStringDescriptor(TInt aIndex, const TUsbcStringDescriptor* aDesc)
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::ExchangeStringDescriptor()"));
-    TUsbcStringDescriptorBase* const ptr = iStrings[aIndex];
-    __KTRACE_OPT(KUSB, Kern::Printf("  Deleting string descriptor at index %d: 0x%x", aIndex, ptr));
-    iStrings.Remove(aIndex);
-    delete ptr;
-    __KTRACE_OPT(KUSB, Kern::Printf("  Inserting string descriptor at index %d: 0x%x", aIndex, aDesc));
-    iStrings.Insert(aDesc, aIndex);
-    }
-
-
-//
-// Checks whether there are any string descriptors in the array (apart from LangID).
-//
-TBool TUsbcDescriptorPool::AnyStringDescriptors() const
-    {
-    const TInt n = iStrings.Count();
-    for (TInt i = 1; i < n; i++)
-        {
-        if (iStrings[i] != NULL)
-            return ETrue;
-        }
-    return EFalse;
-    }
-
-
-//
-// Returns true if aIndex exists and what is at that positition is not a NULL pointer.
-//
-TBool TUsbcDescriptorPool::StringDescriptorExists(TInt aIndex) const
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::StringDescriptorExists()"));
-    if (aIndex >= iStrings.Count())
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Bad string index: %d", aIndex));
-        return EFalse;
-        }
-    else if (iStrings[aIndex] == NULL)
-        {
-        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: No $ descriptor @ pos %d", aIndex));
-        return EFalse;
-        }
-    return ETrue;
-    }
-
-
-//
-//
-//
-TInt TUsbcDescriptorPool::FindAvailableStringPos() const
-    {
-    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::FindAvailableStringPos()"));
-    const TInt n = iStrings.Count();
-    // We don't start from 0 because the first few locations are 'reserved'.
-    for (TInt i = KStringPosition_FirstAvailable; i < n; i++)
-        {
-        if (iStrings[i] == NULL)
-            {
-            __KTRACE_OPT(KUSB, Kern::Printf(" Found available NULL position: %d", i));
-            return i;
-            }
-        }
-    return -1;
-    }
-
-
-// -eof-