1 // Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32/drivers/usbcc/descriptors.cpp

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

    16 // USB descriptor handling and management.

    17 // 

    18 //

    19 

    20 /**

    21  @file descriptors.cpp

    22  @internalTechnology

    23 */

    24 

    25 #include <kernel/kern_priv.h>

    26 // #include <drivers/usbc.h>

    27 #include <usb/usbc.h>

    28 

    29 

    30 // Debug Support

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

    32 

    33 

    34 // --- TUsbcDescriptorBase

    35 

    36 TUsbcDescriptorBase::TUsbcDescriptorBase()

    37     :

    38 #ifdef USB_SUPPORTS_SET_DESCRIPTOR_REQUEST

    39     iIndex(0),

    40 #endif

    41     iBufPtr(NULL, 0)

    42     {

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

    44     }

    45 

    46 

    47 TUsbcDescriptorBase::~TUsbcDescriptorBase()

    48     {

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

    50     }

    51 

    52 

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

    54     {

    55     iBufPtr[aPosition] = aValue;

    56     }

    57 

    58 

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

    60     {

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

    62     }

    63 

    64 

    65 TUint8 TUsbcDescriptorBase::Byte(TInt aPosition) const

    66     {

    67     return iBufPtr[aPosition];

    68     }

    69 

    70 

    71 TUint16 TUsbcDescriptorBase::Word(TInt aPosition) const

    72     {

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

    74     }

    75 

    76 

    77 void TUsbcDescriptorBase::GetDescriptorData(TDes8& aBuffer) const

    78     {

    79     aBuffer = iBufPtr;

    80     }

    81 

    82 

    83 TInt TUsbcDescriptorBase::GetDescriptorData(TUint8* aBuffer) const

    84     {

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

    86     return Size();

    87     }

    88 

    89 

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

    91     {

    92     if (aMaxSize < Size())

    93         {

    94         // No use to copy only half a descriptor

    95         return 0;

    96         }

    97     return GetDescriptorData(aBuffer);

    98     }

    99 

   100 

   101 const TDes8& TUsbcDescriptorBase::DescriptorData() const

   102     {

   103     return iBufPtr;

   104     }

   105 

   106 

   107 TDes8& TUsbcDescriptorBase::DescriptorData()

   108     {

   109     return iBufPtr;

   110     }

   111 

   112 

   113 TUint TUsbcDescriptorBase::Size() const

   114     {

   115     return iBufPtr.Size();

   116     }

   117 

   118 

   119 TUint8 TUsbcDescriptorBase::Type() const

   120     {

   121     return iBufPtr[1];

   122     }

   123 

   124 

   125 void TUsbcDescriptorBase::UpdateFs()

   126     {

   127     // virtual function can be overridden in derived classes.

   128     return;

   129     }

   130 

   131 

   132 void TUsbcDescriptorBase::UpdateHs()

   133     {

   134     // virtual function can be overridden in derived classes.

   135     return;

   136     }

   137 

   138 

   139 void TUsbcDescriptorBase::SetBufferPointer(const TDesC8& aDes)

   140     {

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

   142     }

   143 

   144 

   145 // --- TUsbcDeviceDescriptor

   146 

   147 TUsbcDeviceDescriptor::TUsbcDeviceDescriptor()

   148     : iBuf()

   149     {

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

   151     }

   152 

   153 

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

   155                                                   TUint8 aDeviceProtocol, TUint8 aMaxPacketSize0,

   156                                                   TUint16 aVendorId, TUint16 aProductId,

   157                                                   TUint16 aDeviceRelease, TUint8 aNumConfigurations)

   158     {

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

   160     TUsbcDeviceDescriptor* self = new TUsbcDeviceDescriptor();

   161     if (self)

   162         {

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

   164                             aProductId, aDeviceRelease, aNumConfigurations) != KErrNone)

   165             {

   166             delete self;

   167             return NULL;

   168             }

   169         }

   170     return self;

   171     }

   172 

   173 

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

   175                                       TUint8 aMaxPacketSize0, TUint16 aVendorId, TUint16 aProductId,

   176                                       TUint16 aDeviceRelease, TUint8 aNumConfigurations)

   177     {

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

   179     iBuf.SetMax();

   180     SetBufferPointer(iBuf);

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

   182     iBuf[1] = KUsbDescType_Device;                            // bDescriptorType

   183     SetWord(2, KUsbcUsbVersion);                            // bcdUSB

   184     iBuf[4] = aDeviceClass;                                    // bDeviceClass

   185     iBuf[5] = aDeviceSubClass;                                // bDeviceSubClass

   186     iBuf[6] = aDeviceProtocol;                                // bDeviceProtocol

   187     iBuf[7] = aMaxPacketSize0;                                // bMaxPacketSize0

   188     SetWord(8, aVendorId);                                    // idVendor

   189     SetWord(10, aProductId);                                // idProduct

   190     SetWord(12, aDeviceRelease);                            // bcdDevice

   191     iBuf[14] = 0;                                            // iManufacturer

   192     iBuf[15] = 0;                                            // iProduct

   193     iBuf[16] = 0;                                            // iSerialNumber

   194     iBuf[17] = aNumConfigurations;                            // bNumConfigurations

   195     iEp0Size_Fs = aMaxPacketSize0;

   196     return KErrNone;

   197     }

   198 

   199 

   200 void TUsbcDeviceDescriptor::UpdateFs()

   201     {

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

   203     SetByte(7, iEp0Size_Fs);                                // bMaxPacketSize0

   204     }

   205 

   206 

   207 void TUsbcDeviceDescriptor::UpdateHs()

   208     {

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

   210     SetByte(7, 64);                                            // bMaxPacketSize0

   211     }

   212 

   213 

   214 // --- TUsbcDeviceQualifierDescriptor

   215 

   216 TUsbcDeviceQualifierDescriptor::TUsbcDeviceQualifierDescriptor()

   217     : iBuf()

   218     {

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

   220     }

   221 

   222 

   223 TUsbcDeviceQualifierDescriptor* TUsbcDeviceQualifierDescriptor::New(TUint8 aDeviceClass,

   224                                                                     TUint8 aDeviceSubClass,

   225                                                                     TUint8 aDeviceProtocol,

   226                                                                     TUint8 aMaxPacketSize0,

   227                                                                     TUint8 aNumConfigurations,

   228                                                                     TUint8 aReserved)

   229     {

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

   231     TUsbcDeviceQualifierDescriptor* self = new TUsbcDeviceQualifierDescriptor();

   232     if (self)

   233         {

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

   235                             aNumConfigurations, aReserved) != KErrNone)

   236             {

   237             delete self;

   238             return NULL;

   239             }

   240         }

   241     return self;

   242     }

   243 

   244 

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

   246                                                TUint8 aDeviceProtocol, TUint8 aMaxPacketSize0,

   247                                                TUint8 aNumConfigurations, TUint8 aReserved)

   248     {

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

   250     iBuf.SetMax();

   251     SetBufferPointer(iBuf);

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

   253     iBuf[1] = KUsbDescType_DeviceQualifier;                    // bDescriptorType

   254     SetWord(2, KUsbcUsbVersion);                            // bcdUSB

   255     iBuf[4] = aDeviceClass;                                    // bDeviceClass

   256     iBuf[5] = aDeviceSubClass;                                // bDeviceSubClass

   257     iBuf[6] = aDeviceProtocol;                                // bDeviceProtocol

   258     iBuf[7] = aMaxPacketSize0;                                // bMaxPacketSize0

   259     iBuf[8] = aNumConfigurations;                            // bNumConfigurations

   260     if (aReserved) aReserved = 0;

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

   262     iEp0Size_Fs = aMaxPacketSize0;

   263     return KErrNone;

   264     }

   265 

   266 

   267 void TUsbcDeviceQualifierDescriptor::UpdateFs()

   268     {

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

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

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

   272     SetByte(7, 64);                                            // bMaxPacketSize0

   273     }

   274 

   275 

   276 void TUsbcDeviceQualifierDescriptor::UpdateHs()

   277     {

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

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

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

   281     SetByte(7, iEp0Size_Fs);                                // bMaxPacketSize0

   282     }

   283 

   284 

   285 // --- TUsbcConfigDescriptor

   286 

   287 TUsbcConfigDescriptor::TUsbcConfigDescriptor()

   288     : iBuf()

   289     {

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

   291     }

   292 

   293 

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

   295                                                   TBool aRemoteWakeup, TUint16 aMaxPower)

   296     {

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

   298     TUsbcConfigDescriptor* self = new TUsbcConfigDescriptor();

   299     if (self)

   300         {

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

   302             {

   303             delete self;

   304             return NULL;

   305             }

   306         }

   307     return self;

   308     }

   309 

   310 

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

   312                                        TBool aRemoteWakeup, TUint16 aMaxPower)

   313     {

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

   315     iBuf.SetMax();

   316     SetBufferPointer(iBuf);

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

   318     iBuf[1] = KUsbDescType_Config;                            // bDescriptorType

   319     SetWord(2, KUsbDescSize_Config);                        // wTotalLength

   320     iBuf[4] = 0;                                            // bNumInterfaces

   321     iBuf[5] = aConfigurationValue;                            // bConfigurationValue

   322     iBuf[6] = 0;                                            // iConfiguration

   323     iBuf[7] = 0x80 |

   324         (aSelfPowered ? KUsbDevAttr_SelfPowered : 0) |

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

   326     if (aMaxPower > 510)

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

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

   329     return KErrNone;

   330     }

   331 

   332 

   333 // --- TUsbcInterfaceDescriptor

   334 

   335 TUsbcInterfaceDescriptor::TUsbcInterfaceDescriptor()

   336     : iBuf()

   337     {

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

   339     }

   340 

   341 

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

   343                                                         TInt aNumEndpoints, const TUsbcClassInfo& aClassInfo)

   344     {

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

   346     TUsbcInterfaceDescriptor* self = new TUsbcInterfaceDescriptor();

   347     if (self)

   348         {

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

   350             {

   351             delete self;

   352             return NULL;

   353             }

   354         }

   355     return self;

   356     }

   357 

   358 

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

   360                                          TInt aNumEndpoints, const TUsbcClassInfo& aClassInfo)

   361     {

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

   363     iBuf.SetMax();

   364     SetBufferPointer(iBuf);

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

   366     iBuf[1] = KUsbDescType_Interface;                        // bDescriptorType

   367     iBuf[2] = aInterfaceNumber;                                // bInterfaceNumber

   368     iBuf[3] = aAlternateSetting;                            // bAlternateSetting

   369     iBuf[4] = aNumEndpoints;                                // bNumEndpoints

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

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

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

   373     iBuf[8] = 0;                                            // iInterface

   374     return KErrNone;

   375     }

   376 

   377 

   378 // --- TUsbcEndpointDescriptorBase

   379 

   380 TUsbcEndpointDescriptorBase::TUsbcEndpointDescriptorBase()

   381     {

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

   383     }

   384 

   385 

   386 TInt TUsbcEndpointDescriptorBase::Construct(const TUsbcEndpointInfo& aEpInfo)

   387     {

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

   389     //  Adjust FS/HS endpoint sizes

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

   391         {

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

   393         }

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

   395                                     iEpSize_Fs, iEpSize_Hs, aEpInfo.iSize));

   396 

   397     //  Adjust HS endpoint size for additional transactions

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

   399         {

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

   401             {

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

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

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

   405                                             "(aEpInfo.iTransactions=%d)",

   406                                             iEpSize_Hs, aEpInfo.iTransactions));

   407             }

   408         else if (aEpInfo.iTransactions != 0)

   409             {

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

   411                                               aEpInfo.iTransactions));

   412             }

   413         }

   414 

   415     //  Adjust HS polling interval

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

   417     if (info.AdjustPollInterval() != KErrNone)

   418         {

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

   420                                           info.iType, info.iInterval));

   421         }

   422     iInterval_Fs = info.iInterval;

   423     iInterval_Hs = info.iInterval_Hs;

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

   425                                     iInterval_Fs, iInterval_Hs));

   426     return KErrNone;

   427     }

   428 

   429 

   430 void TUsbcEndpointDescriptorBase::UpdateFs()

   431     {

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

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

   434     //  adjusted in its Construct() method.)

   435     SetWord(4, iEpSize_Fs);                                    // wMaxPacketSize

   436     SetByte(6, iInterval_Fs);                                // bInterval

   437     }

   438 

   439 

   440 void TUsbcEndpointDescriptorBase::UpdateHs()

   441     {

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

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

   444     //  adjusted in its Construct() method.)

   445     SetWord(4, iEpSize_Hs);                                    // wMaxPacketSize

   446     SetByte(6, iInterval_Hs);                                // bInterval

   447     }

   448 

   449 

   450 // --- TUsbcEndpointDescriptor

   451 

   452 TUsbcEndpointDescriptor::TUsbcEndpointDescriptor()

   453     : iBuf()

   454     {

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

   456     }

   457 

   458 

   459 TUsbcEndpointDescriptor* TUsbcEndpointDescriptor::New(TUint8 aEndpointAddress,

   460                                                       const TUsbcEndpointInfo& aEpInfo)

   461     {

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

   463     TUsbcEndpointDescriptor* self = new TUsbcEndpointDescriptor();

   464     if (self)

   465         {

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

   467             {

   468             delete self;

   469             return NULL;

   470             }

   471         }

   472     return self;

   473     }

   474 

   475 

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

   477     {

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

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

   480     iBuf.SetMax();

   481     SetBufferPointer(iBuf);

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

   483     iBuf[1] = KUsbDescType_Endpoint;                        // bDescriptorType

   484     iBuf[2] = aEndpointAddress;                                // bEndpointAddress

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

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

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

   488     return KErrNone;

   489     }

   490 

   491 

   492 // --- TUsbcAudioEndpointDescriptor

   493 

   494 TUsbcAudioEndpointDescriptor::TUsbcAudioEndpointDescriptor()

   495     : iBuf()

   496     {

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

   498     }

   499 

   500 

   501 TUsbcAudioEndpointDescriptor* TUsbcAudioEndpointDescriptor::New(TUint8 aEndpointAddress,

   502                                                                 const TUsbcEndpointInfo& aEpInfo)

   503     {

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

   505     TUsbcAudioEndpointDescriptor* self = new TUsbcAudioEndpointDescriptor();

   506     if (self)

   507         {

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

   509             {

   510             delete self;

   511             return NULL;

   512             }

   513         }

   514     return self;

   515     }

   516 

   517 

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

   519     {

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

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

   522     iBuf.SetMax();

   523     SetBufferPointer(iBuf);

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

   525     iBuf[1] = KUsbDescType_Endpoint;                        // bDescriptorType

   526     iBuf[2] = aEndpointAddress;                                // bEndpointAddress

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

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

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

   530     iBuf[7] = 0;

   531     iBuf[8] = 0;

   532     return KErrNone;

   533     }

   534 

   535 

   536 // --- TUsbcOtgDescriptor

   537 

   538 TUsbcOtgDescriptor* TUsbcOtgDescriptor::New(TBool aHnpSupport, TBool aSrpSupport)

   539     {

   540     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcOtgDescriptor::New()"));

   541     TUsbcOtgDescriptor* self = new TUsbcOtgDescriptor();

   542     if (self && (self->Construct(aHnpSupport, aSrpSupport) != KErrNone))

   543         {

   544         delete self;

   545         return NULL;

   546         }

   547     return self;

   548     }

   549 

   550 

   551 TUsbcOtgDescriptor::TUsbcOtgDescriptor()

   552     : iBuf()

   553     {

   554     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcOtgDescriptor::TUsbcOtgDescriptor()"));

   555     }

   556 

   557 

   558 TInt TUsbcOtgDescriptor::Construct(TBool aHnpSupport, TBool aSrpSupport)

   559     {

   560     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcOtgDescriptor::Construct()"));

   561     iBuf.SetMax();

   562     SetBufferPointer(iBuf);

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

   564     iBuf[1] = KUsbDescType_Otg;                                // bDescriptorType

   565     iBuf[2] = (aHnpSupport ? KUsbOtgAttr_HnpSupp : 0) |

   566         (aSrpSupport ? KUsbOtgAttr_SrpSupp : 0);            // bmAttributes

   567     return KErrNone;

   568     }

   569 

   570 

   571 // --- TUsbcClassSpecificDescriptor

   572 

   573 TUsbcClassSpecificDescriptor::TUsbcClassSpecificDescriptor()

   574     : iBuf(NULL)

   575     {

   576     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcClassSpecificDescriptor::TUsbcClassSpecificDescriptor()"));

   577     }

   578 

   579 

   580 TUsbcClassSpecificDescriptor::~TUsbcClassSpecificDescriptor()

   581     {

   582     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcClassSpecificDescriptor::~TUsbcClassSpecificDescriptor()"));

   583     delete iBuf;

   584     }

   585 

   586 

   587 TUsbcClassSpecificDescriptor* TUsbcClassSpecificDescriptor::New(TUint8 aType, TInt aSize)

   588     {

   589     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcClassSpecificDescriptor::New()"));

   590     TUsbcClassSpecificDescriptor* self = new TUsbcClassSpecificDescriptor();

   591     if (self)

   592         {

   593         if (self->Construct(aType, aSize) != KErrNone)

   594             {

   595             delete self;

   596             return NULL;

   597             }

   598         }

   599     return self;

   600     }

   601 

   602 

   603 TInt TUsbcClassSpecificDescriptor::Construct(TUint8 aType, TInt aSize)

   604     {

   605     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcClassSpecificDescriptor::Construct()"));

   606     iBuf = HBuf8::New(aSize);

   607     if (!iBuf)

   608         {

   609         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Allocation of CS desc buffer failed"));

   610         return KErrNoMemory;

   611         }

   612     iBuf->SetMax();

   613     SetBufferPointer(*iBuf);

   614     SetByte(1, aType);                                        // bDescriptorType

   615     return KErrNone;

   616     }

   617 

   618 

   619 // --- TUsbcStringDescriptorBase

   620 

   621 TUsbcStringDescriptorBase::TUsbcStringDescriptorBase()

   622     : /*iIndex(0),*/ iSBuf(0), iBufPtr(NULL, 0)

   623     {

   624     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcStringDescriptorBase::TUsbcStringDescriptorBase()"));

   625     }

   626 

   627 

   628 TUsbcStringDescriptorBase::~TUsbcStringDescriptorBase()

   629     {

   630     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcStringDescriptorBase::~TUsbcStringDescriptorBase()"));

   631     }

   632 

   633 

   634 TUint16 TUsbcStringDescriptorBase::Word(TInt aPosition) const

   635     {

   636     if (aPosition <= 1)

   637         {

   638         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Word(%d) in string descriptor "

   639                                           "(TUsbcStringDescriptorBase::Word)", aPosition));

   640         return 0;

   641         }

   642     else

   643         {

   644         // since iBufPtr[0] is actually string descriptor byte index 2,

   645         // we have to subtract 2 from the absolute position.

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

   647         }

   648     }

   649 

   650 

   651 void TUsbcStringDescriptorBase::SetWord(TInt aPosition, TUint16 aValue)

   652     {

   653     if (aPosition <= 1)

   654         {

   655         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: SetWord(%d) in string descriptor "

   656                                           "(TUsbcStringDescriptorBase::SetWord)", aPosition));

   657         return;

   658         }

   659     else

   660         {

   661         // since iBufPtr[0] is actually string descriptor byte index 2,

   662         // we have to subtract 2 from the absolute position.

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

   664         }

   665     }

   666 

   667 

   668 TInt TUsbcStringDescriptorBase::GetDescriptorData(TUint8* aBuffer) const

   669     {

   670     aBuffer[0] = iSBuf[0];

   671     aBuffer[1] = iSBuf[1];

   672     memcpy(&aBuffer[2], iBufPtr.Ptr(), iBufPtr.Size());

   673     return Size();

   674     }

   675 

   676 

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

   678     {

   679     if (aMaxSize < Size())

   680         {

   681         // No use to copy only half a string

   682         return 0;

   683         }

   684     return GetDescriptorData(aBuffer);

   685     }

   686 

   687 

   688 const TDes8& TUsbcStringDescriptorBase::StringData() const

   689     {

   690     return iBufPtr;

   691     }

   692 

   693 

   694 TDes8& TUsbcStringDescriptorBase::StringData()

   695     {

   696     return iBufPtr;

   697     }

   698 

   699 

   700 TUint TUsbcStringDescriptorBase::Size() const

   701     {

   702     return iSBuf[0];

   703     }

   704 

   705 

   706 void TUsbcStringDescriptorBase::SetBufferPointer(const TDesC8& aDes)

   707     {

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

   709     }

   710 

   711 

   712 // --- TUsbcStringDescriptor

   713 

   714 TUsbcStringDescriptor::TUsbcStringDescriptor()

   715     : iBuf(NULL)

   716     {

   717     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcStringDescriptor::TUsbcStringDescriptor()"));

   718     }

   719 

   720 

   721 TUsbcStringDescriptor::~TUsbcStringDescriptor()

   722     {

   723     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcStringDescriptor::~TUsbcStringDescriptor()"));

   724     delete iBuf;

   725     }

   726 

   727 

   728 TUsbcStringDescriptor* TUsbcStringDescriptor::New(const TDesC8& aString)

   729     {

   730     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcStringDescriptor::New"));

   731     TUsbcStringDescriptor* self = new TUsbcStringDescriptor();

   732     if (self)

   733         {

   734         if (self->Construct(aString) != KErrNone)

   735             {

   736             delete self;

   737             return NULL;

   738             }

   739         }

   740     return self;

   741     }

   742 

   743 

   744 TInt TUsbcStringDescriptor::Construct(const TDesC8& aString)

   745     {

   746     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcStringDescriptor::Construct"));

   747     iBuf = HBuf8::New(aString.Size());                        // bytes, not UNICODE chars

   748     if (!iBuf)

   749         {

   750         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Allocation of string buffer failed"));

   751         return KErrNoMemory;

   752         }

   753     iBuf->SetMax();

   754     SetBufferPointer(*iBuf);

   755     iBufPtr.Copy(aString);

   756     iSBuf.SetMax();

   757     iSBuf[0] = iBuf->Size() + 2;                            // Bytes

   758     iSBuf[1] = KUsbDescType_String;

   759     return KErrNone;

   760     }

   761 

   762 

   763 // --- TUsbcLangIdDescriptor

   764 

   765 TUsbcLangIdDescriptor::TUsbcLangIdDescriptor()

   766     : iBuf(NULL)

   767     {

   768     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcLangIdDescriptor::TUsbcLangIdDescriptor()"));

   769     }

   770 

   771 

   772 TUsbcLangIdDescriptor::~TUsbcLangIdDescriptor()

   773     {

   774     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcLangIdDescriptor::~TUsbcLangIdDescriptor()"));

   775     }

   776 

   777 

   778 TUsbcLangIdDescriptor* TUsbcLangIdDescriptor::New(TUint16 aLangId)

   779     {

   780     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcLangIdDescriptor::New"));

   781     TUsbcLangIdDescriptor* self = new TUsbcLangIdDescriptor();

   782     if (self)

   783         {

   784         if (self->Construct(aLangId) != KErrNone)

   785             {

   786             delete self;

   787             return NULL;

   788             }

   789         }

   790     return self;

   791     }

   792 

   793 

   794 TInt TUsbcLangIdDescriptor::Construct(TUint16 aLangId)

   795     {

   796     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcLangIdDescriptor::Construct"));

   797     iBuf.SetMax();

   798     SetBufferPointer(iBuf);

   799     iBufPtr[0] = LowByte(SWAP_BYTES_16(aLangId));            // Language ID value

   800     iBufPtr[1] = HighByte(SWAP_BYTES_16(aLangId));

   801     iSBuf.SetMax();

   802     iSBuf[0] = iBuf.Size() + 2;                                // Bytes

   803     iSBuf[1] = KUsbDescType_String;

   804     return KErrNone;

   805     }

   806 

   807 

   808 // --- TUsbcDescriptorPool

   809 

   810 TUsbcDescriptorPool::TUsbcDescriptorPool(TUint8* aEp0_TxBuf)

   811 //

   812 //    The constructor for this class.

   813 //

   814     : iDescriptors(), iStrings(), iIfcIdx(0), iEp0_TxBuf(aEp0_TxBuf), iHighSpeed(EFalse)

   815     {

   816     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::TUsbcDescriptorPool()"));

   817     }

   818 

   819 

   820 TUsbcDescriptorPool::~TUsbcDescriptorPool()

   821     {

   822     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::~TUsbcDescriptorPool()"));

   823     // The destructor of each <class T> object is called before the objects themselves are destroyed.

   824     __KTRACE_OPT(KUSB, Kern::Printf("  iDescriptors.Count(): %d", iDescriptors.Count()));

   825     iDescriptors.ResetAndDestroy();

   826     __KTRACE_OPT(KUSB, Kern::Printf("  iStrings.Count(): %d", iStrings.Count()));

   827     iStrings.ResetAndDestroy();

   828     }

   829 

   830 

   831 TInt TUsbcDescriptorPool::Init(TUsbcDeviceDescriptor* aDeviceDesc, TUsbcConfigDescriptor* aConfigDesc,

   832                                TUsbcLangIdDescriptor* aLangId, TUsbcStringDescriptor* aManufacturer,

   833                                TUsbcStringDescriptor* aProduct, TUsbcStringDescriptor* aSerialNum,

   834                                TUsbcStringDescriptor* aConfig, TUsbcOtgDescriptor* aOtgDesc)

   835     {

   836     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::Init()"));

   837     if (!aDeviceDesc || !aConfigDesc)

   838         {

   839         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: No Device or Config descriptor specified"));

   840         return KErrArgument;

   841         }

   842     for (TInt n = 0; n < KDescPosition_FirstAvailable; n++)

   843         {

   844         iDescriptors.Append(NULL);

   845         }

   846     __ASSERT_DEBUG((iDescriptors.Count() == KDescPosition_FirstAvailable),

   847                    Kern::Printf("  Error: iDescriptors.Count() (%d) != KDescPosition_FirstAvailable (%d)",

   848                                 iDescriptors.Count(), KDescPosition_FirstAvailable));

   849     iDescriptors[KDescPosition_Device] = aDeviceDesc;

   850     iDescriptors[KDescPosition_Config] = aConfigDesc;

   851     if (aOtgDesc)

   852         {

   853         iDescriptors[KDescPosition_Otg] = aOtgDesc;

   854         // Update the config descriptor's wTotalLength field

   855         UpdateConfigDescriptorLength(KUsbDescSize_Otg);

   856         }

   857     if (!aLangId)

   858         {

   859         // USB spec 9.6.7 says: "String index zero for all languages returns a string descriptor

   860         // that contains an array of two-byte LANGID codes supported by the device. ...

   861         // USB devices that omit all string descriptors must not return an array of LANGID codes."

   862         // So if we have at least one string descriptor, we must also have a LANGID descriptor.

   863         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: No LANGID string descriptor specified"));

   864         return KErrArgument;

   865         }

   866     iStrings.Insert(aLangId, KStringPosition_Langid);

   867     iStrings.Insert(aManufacturer, KStringPosition_Manufact);

   868     iStrings.Insert(aProduct, KStringPosition_Product);

   869     iStrings.Insert(aSerialNum, KStringPosition_Serial);

   870     iStrings.Insert(aConfig, KStringPosition_Config);

   871     __ASSERT_DEBUG((iStrings.Count() == 5),

   872                    Kern::Printf("  Error: iStrings.Count() != 5 (%d)", iStrings.Count()));

   873 #ifdef _DEBUG

   874     for (TInt i = KStringPosition_Langid; i <= KStringPosition_Config; i++)

   875         {

   876         __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool.iStrings[%d] = 0x%x", i, iStrings[i]));

   877         }

   878 #endif

   879     // Set string indices

   880     if (aManufacturer)

   881         iDescriptors[KDescPosition_Device]->SetByte(KUsbDescStringIndex_Manufact,

   882                                                     KStringPosition_Manufact);

   883     if (aProduct)

   884         iDescriptors[KDescPosition_Device]->SetByte(KUsbDescStringIndex_Product,

   885                                                     KStringPosition_Product);

   886     if (aSerialNum)

   887         iDescriptors[KDescPosition_Device]->SetByte(KUsbDescStringIndex_Serial,

   888                                                     KStringPosition_Serial);

   889     if (aConfig)

   890         iDescriptors[KDescPosition_Config]->SetByte(KUsbDescStringIndex_Config,

   891                                                     KStringPosition_Config);

   892     return KErrNone;

   893     }

   894 

   895 

   896 TInt TUsbcDescriptorPool::InitHs()

   897     {

   898     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::InitHs()"));

   899     __ASSERT_DEBUG((iDescriptors.Count() >= KDescPosition_FirstAvailable),

   900                    Kern::Printf("  Error: Call Init() first)"));

   901 

   902     TUsbcDeviceQualifierDescriptor* const dq_desc = TUsbcDeviceQualifierDescriptor::New(

   903         iDescriptors[KDescPosition_Device]->Byte(4),        // aDeviceClass

   904         iDescriptors[KDescPosition_Device]->Byte(5),        // aDeviceSubClass

   905         iDescriptors[KDescPosition_Device]->Byte(6),        // aDeviceProtocol

   906         iDescriptors[KDescPosition_Device]->Byte(7),        // aMaxPacketSize0

   907         iDescriptors[KDescPosition_Device]->Byte(17));        // aNumConfigurations

   908     if (!dq_desc)

   909         {

   910         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for dev qualif desc failed."));

   911         return KErrGeneral;

   912         }

   913     iDescriptors[KDescPosition_DeviceQualifier] = dq_desc;

   914 

   915     TUsbcOtherSpeedConfigDescriptor* const osc_desc = TUsbcOtherSpeedConfigDescriptor::New(

   916         iDescriptors[KDescPosition_Config]->Byte(5),        // aConfigurationValue

   917         iDescriptors[KDescPosition_Config]->Byte(7) & KUsbDevAttr_SelfPowered, // aSelfPowered

   918         iDescriptors[KDescPosition_Config]->Byte(7) & KUsbDevAttr_RemoteWakeup,    // aRemoteWakeup

   919         iDescriptors[KDescPosition_Config]->Byte(8) * 2);    // aMaxPower (mA)

   920     if (!osc_desc)

   921         {

   922         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Memory allocation for other speed conf desc failed."));

   923         return KErrGeneral;

   924         }

   925 

   926     // We need to set the bDescriptorType field manually, as that's the only one

   927     // that differs from a Configuration descriptor.

   928     osc_desc->SetByte(1, KUsbDescType_OtherSpeedConfig);

   929 

   930     // Also, initially we set the iConfiguration string index to the same value as

   931     // in the Configuration descriptor.

   932     osc_desc->SetByte(KUsbDescStringIndex_Config,

   933                       iDescriptors[KDescPosition_Config]->Byte(KUsbDescStringIndex_Config));

   934 

   935     iDescriptors[KDescPosition_OtherSpeedConfig] = osc_desc;

   936 

   937     return KErrNone;

   938     }

   939 

   940 

   941 TInt TUsbcDescriptorPool::UpdateDescriptorsFs()

   942     {

   943     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::UpdateDescriptorsFs()"));

   944     const TInt count = iDescriptors.Count();

   945     for (TInt i = KDescPosition_FirstAvailable; i < count; i++)

   946         {

   947         TUsbcDescriptorBase* const ptr = iDescriptors[i];

   948         ptr->UpdateFs();

   949         }

   950     iHighSpeed = EFalse;

   951     return KErrNone;

   952     }

   953 

   954 

   955 TInt TUsbcDescriptorPool::UpdateDescriptorsHs()

   956     {

   957     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::UpdateDescriptorsHs()"));

   958     const TInt count = iDescriptors.Count();

   959     for (TInt i = KDescPosition_FirstAvailable; i < count; i++)

   960         {

   961         TUsbcDescriptorBase* const ptr = iDescriptors[i];

   962         ptr->UpdateHs();

   963         }

   964     iHighSpeed = ETrue;

   965     return KErrNone;

   966     }

   967 

   968 

   969 //

   970 // An error can be indicated by either a return value != KErrNone or by a descriptor size == 0.

   971 //

   972 TInt TUsbcDescriptorPool::FindDescriptor(TUint8 aType, TUint8 aIndex, TUint16 aLangid, TInt& aSize) const

   973     {

   974     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::FindDescriptor()"));

   975     TInt result = KErrGeneral;

   976     switch (aType)

   977         {

   978     case KUsbDescType_Device:

   979         if (aLangid != 0)

   980             {

   981             __KTRACE_OPT(KPANIC, Kern::Printf("  Error: bad langid: 0x%04x", aLangid));

   982             }

   983         else if (aIndex > 0)

   984             {

   985             __KTRACE_OPT(KPANIC, Kern::Printf("  Error: bad device index: %d", aIndex));

   986             }

   987         else

   988             {

   989             aSize = GetDeviceDescriptor(KDescPosition_Device);

   990             result = KErrNone;

   991             }

   992         break;

   993     case KUsbDescType_Config:

   994         if (aLangid != 0)

   995             {

   996             __KTRACE_OPT(KPANIC, Kern::Printf("  Error: bad langid: 0x%04x", aLangid));

   997             }

   998         else if (aIndex > 0)

   999             {

  1000             __KTRACE_OPT(KPANIC, Kern::Printf("  Error: bad config index: %d", aIndex));

  1001             }

  1002         else

  1003             {

  1004             aSize = GetConfigurationDescriptor(KDescPosition_Config);

  1005             result = KErrNone;

  1006             }

  1007         break;

  1008     case KUsbDescType_DeviceQualifier:

  1009         if (aLangid != 0)

  1010             {

  1011             __KTRACE_OPT(KPANIC, Kern::Printf("  Error: bad langid: 0x%04x", aLangid));

  1012             }

  1013         else if (aIndex > 0)

  1014             {

  1015             __KTRACE_OPT(KPANIC, Kern::Printf("  Error: bad device index: %d", aIndex));

  1016             }

  1017         else

  1018             {

  1019             aSize = GetDeviceDescriptor(KDescPosition_DeviceQualifier);

  1020             result = KErrNone;

  1021             }

  1022         break;

  1023     case KUsbDescType_OtherSpeedConfig:

  1024         if (aLangid != 0)

  1025             {

  1026             __KTRACE_OPT(KPANIC, Kern::Printf("  Error: bad langid: 0x%04x", aLangid));

  1027             }

  1028         else if (aIndex > 0)

  1029             {

  1030             __KTRACE_OPT(KPANIC, Kern::Printf("  Error: bad config index: %d", aIndex));

  1031             }

  1032         else

  1033             {

  1034             aSize = GetConfigurationDescriptor(KDescPosition_OtherSpeedConfig);

  1035             result = KErrNone;

  1036             }

  1037         break;

  1038     case KUsbDescType_Otg:

  1039         aSize = GetOtgDescriptor();

  1040         result = KErrNone;

  1041         break;

  1042     case KUsbDescType_String:

  1043         if (aIndex == 0)                                    // 0 addresses the LangId array

  1044             {

  1045             if (AnyStringDescriptors())

  1046                 {

  1047                 aSize = GetStringDescriptor(aIndex);

  1048                 result = KErrNone;

  1049                 }

  1050             else

  1051                 {

  1052                 __KTRACE_OPT(KUSB, Kern::Printf("  No string descriptors: not returning LANGID array"));

  1053                 }

  1054             }

  1055         else

  1056             {

  1057                if (!aLangid)

  1058                    {

  1059                    __KTRACE_OPT(KUSB,

  1060                               Kern::Printf("  Strange: LANGID=0 for a $ descriptor (ignoring LANGID)"));

  1061                 // The USB spec doesn't really say what to do in this case, but as there are host apps

  1062                 // that fail if we return an error here, we choose to ignore the issue.

  1063                    }

  1064             else if (aLangid != iStrings[KStringPosition_Langid]->Word(2))

  1065                 {

  1066                 // We have only one (this) language

  1067                 __KTRACE_OPT(KUSB,

  1068                              Kern::Printf("  Bad LANGID: 0x%04X requested, 0x%04X supported (ignoring LANGID)",

  1069                                           aLangid, iStrings[KStringPosition_Langid]->Word(2)));

  1070                 // We could return an error here, but rather choose to ignore the discrepancy

  1071                 // (the USB spec is not very clear what to do in such a case anyway).

  1072                 }

  1073             aSize = GetStringDescriptor(aIndex);

  1074             result = KErrNone;

  1075             }

  1076         break;

  1077     case KUsbDescType_CS_Interface:

  1078         /* fall through */

  1079     case KUsbDescType_CS_Endpoint:

  1080         __KTRACE_OPT(KPANIC, Kern::Printf("  Warning: finding of class specific descriptors not supported"));

  1081         break;

  1082     default:

  1083         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: unknown descriptor type requested: %d", aType));

  1084         break;

  1085         }

  1086     return result;

  1087     }

  1088 

  1089 

  1090 void TUsbcDescriptorPool::InsertDescriptor(TUsbcDescriptorBase* aDesc)

  1091     {

  1092     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::InsertDescriptor()"));

  1093     switch (aDesc->Type())

  1094         {

  1095     case KUsbDescType_Interface:

  1096         InsertIfcDesc(aDesc);

  1097         break;

  1098     case KUsbDescType_Endpoint:

  1099         InsertEpDesc(aDesc);

  1100         break;

  1101     default:

  1102         __KTRACE_OPT(KUSB, Kern::Printf("  Error: unsupported descriptor type"));

  1103         }

  1104     }

  1105 

  1106 

  1107 void TUsbcDescriptorPool::SetIfcStringDescriptor(TUsbcStringDescriptor* aDesc, TInt aNumber, TInt aSetting)

  1108     {

  1109     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcDescriptorPool::SetIfcDescriptor(%d, %d)", aNumber, aSetting));

  1110     const TInt i = FindIfcDescriptor(aNumber, aSetting);

  1111     if (i < 0)

  1112         {

  1113         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Ifc descriptor not found (%d, %d)",

  1114                                           aNumber, aSetting));

  1115         return;

  1116         }

  1117     // Try to find available NULL postition

  1118     TInt str_idx = FindAvailableStringPos();

  1119     if (str_idx >= 0)

  1120         {

  1121         // Insert string descriptor for specified interface

  1122         ExchangeStringDescriptor(str_idx, aDesc);

  1123         }

  1124     else

  1125         {

  1126         // No NULL found - expand array

  1127         str_idx = iStrings.Count();

  1128         if (str_idx > 0xff)

  1129             {

  1130             __KTRACE_OPT(KPANIC, Kern::Printf("  Error: $ descriptor array full (idx=%d)", str_idx));

  1131             return;

  1132             }

  1133         while (str_idx < KStringPosition_FirstAvailable)

  1134             {

  1135             iStrings.Append(NULL);