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/ps_usbc.cpp

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

    16 // Interface to the USB LDD.

    17 // 

    18 //

    19 

    20 /**

    21  @file ps_usbc.cpp

    22  @internalTechnology

    23 */

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

    25 #include <usb/usbc.h>

    26 

    27 #include "controltransfersm.h"

    28 /**

    29     TUsbcInterfaceSet and TUsbcInterface

    30     ====================================

    31 

    32     TUsbcInterfaceSet represents a 'USB Interface' and TUsbcInterface

    33     represents an 'Alternate Setting of a USB Interface'.

    34 

    35     Since every LDD governs exactly one interface, the above distinction is

    36     made only within the USB implementation. At the LDD API, there is/are

    37     simply one or more settings for this single interface, numbered from '0'

    38     (the default) to 'n', and specified by the parameter 'TInt aInterfaceNum'.

    39 

    40     Within the PDD implementation, for a TUsbcInterfaceSet number the parameter

    41     'TInt aIfcSet' is used (local variable ifcset); for a TUsbcInterface number

    42     the parameter 'TInt aIfc' is used (local variable ifc).

    43 

    44 

    45     iConfigs[0] and CurrentConfig()

    46     ===============================

    47 

    48     One problem with this file is that it always uses iConfigs[0] and not

    49     CurrentConfig(). This is mainly because the API to the LDD doesn't know

    50     about the concept of multiple configurations, and thus always assumes one

    51     single configuration (which is also always active: a further problem).

    52 

    53     In the file chapter9.cpp this issue doesn't exist, since there we always

    54     have to obey the USB protocol, and in this way will use the configuration

    55     which is selected by the host (which will then again currently always be

    56     iConfigs[0].)

    57 

    58     iEp0ClientId

    59     ==================================

    60 

    61     The purpose of these two members of class DUsbClientController is the

    62     following.

    63 

    64     They are used only during Ep0 control transactions which have an OUT (Rx)

    65     data stage. We cannot deduce from the received data itself to whom

    66     it is addressed (that's because of the shared nature of Ep0).

    67 

    68     In order to be able to tell whether received Ep0 data is to be processed by

    69     the PIL or a LDD, we use iEp0ClientId. iEp0ClientId is usually NULL, which

    70     means it is our data. However it is set to the client ID of an LDD in case

    71     2) above. That way we can subsequently hand over received data to the

    72     correct client LDD.

    73 

    74     iEp0DataReceived tracks the amount of data already received - it is used to

    75     determine the end of the DATA_OUT phase, irrespective of the owner of the

    76     data. The total amount that is to be received can be obtained via

    77     iConTransferMgr->PktParser().Length(). (iConTransferMgr->PktParser() holds in 

    78     that case the Setup packet of the current Control transfer.)

    79 

    80     iEp0ClientDataTransmitting is only set to TRUE if a client sets up an Ep0

    81     write. After that transmission has completed we use this value to decide

    82     whether we have to report the completion to a client or not. (If this

    83     variable is FALSE, we did set up the write and thus no client notification

    84     is necessary.)

    85 

    86 */

    87 

    88 //

    89 // === Global and Local Variables ==================================================================

    90 //

    91 

    92 // Currently we support at most 2 peripheral stack

    93 GLDEF_D DUsbClientController* DUsbClientController::UsbClientController[] = {NULL, NULL};

    94 

    95 static const TInt KUsbReconnectDelay   = 500;                // milliseconds

    96 

    97 // Charger detector is the guy(PSL) who can detect the charger type and report 

    98 // it via a charger type observer

    99 static UsbShai::MChargerDetectorIf* gChargerDetector = NULL;

   100 

   101 // Charger observer is the guy who want to monitor the chager type event.

   102 static UsbShai::MChargerDetectorObserverIf* gChargerObsever = NULL;

   103 

   104 

   105 // Those const variables are used to construct the default 

   106 // Usb descriptors, Upper layer can change them later.

   107 /** Default vendor ID to set in device descriptor */

   108 static const TUint16 KUsbVendorId   = KUsbVendorId_Symbian;

   109 /** Default product ID to set in device descriptor */

   110 static const TUint16 KUsbProductId  = 0x1111;

   111 /** Default language ID (US English) to set in device descriptor */

   112 static const TUint16 KUsbLangId     = 0x0409;

   113 static const TUint8 KUsbNumberOfConfiguration = 0x01;

   114 /** Default manufacturer string */

   115 static const wchar_t KStringManufacturer[] = L"Nokia Corporation";

   116 /** Default product name string */

   117 static const wchar_t KStringProduct[]      = L"Nokia USB Driver";

   118 /** Default configuration name string */

   119 static const wchar_t KStringConfig[]       = L"Bulk transfer method configuration";

   120 /** Default configuration name string */

   121 static const wchar_t KStringSerial[]       = L"Serial Not defined";

   122 

   123 

   124 //

   125 // === USB Controller member function implementations - LDD API (public) ===========================

   126 //

   127 

   128 DECLARE_STANDARD_EXTENSION()//lint !e1717 !e960 defined by symbian

   129     {

   130     __KTRACE_OPT(KUSB, Kern::Printf("> Peripheral PIL Extension entry"));

   131     // Don't need to do anything here, using extension just to make sure

   132     // we're loaded when peripheral PSL trying to register itself to us.

   133     __KTRACE_OPT(KUSB, Kern::Printf("< Peripheral PIL Extension exit"));

   134     return KErrNone;

   135     }

   136     

   137 /** The class destructor.

   138 

   139     This rarely gets called, except, for example when something goes

   140     wrong during construction.

   141 

   142     It's not exported because it is virtual.

   143 */

   144 DUsbClientController::~DUsbClientController()

   145     {

   146     __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::~DUsbClientController()"));

   147     if (iPowerHandler)

   148         {

   149         iPowerHandler->Remove();

   150         delete iPowerHandler;

   151         }

   152 

   153     // ResetAndDestroy() will call for every array element the destructor of the pointed-to object,

   154     // before deleting the element itself, and closing the array.

   155     iConfigs.ResetAndDestroy();

   156     __KTRACE_OPT(KUSB, Kern::Printf("< DUsbClientController::~DUsbClientController(): Done."));

   157     }

   158 

   159 EXPORT_C DUsbClientController* DUsbClientController::Create(UsbShai::MPeripheralControllerIf&               aPeripheralControllerIf, 

   160                                                             const UsbShai::TPeripheralControllerProperties& aProperties,

   161                                                             TBool                                  aIsOtgPort)

   162     {

   163     __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::Create"));

   164         // Attempt to create the object

   165     DUsbClientController* usbcc = new DUsbClientController(aPeripheralControllerIf, 

   166                                                            aProperties,

   167                                                            aIsOtgPort);

   168     

   169     __ASSERT_DEBUG( (usbcc != NULL), Kern::Fault( "  USB PSL Out of memory, DUsbClientController", __LINE__ ) );

   170     

   171     if (usbcc != NULL)

   172         {

   173         // Second phase constructor

   174         TInt err = usbcc->Construct();

   175         __ASSERT_DEBUG( (err == KErrNone), Kern::Fault( "DUsbClientController::Construct failed", err) );

   176         

   177         if (err != KErrNone)

   178             {

   179             delete usbcc;

   180             usbcc = NULL;

   181             }

   182         }

   183     

   184     __KTRACE_OPT(KUSB, Kern::Printf("< DUsbClientController::Create instance = %d",usbcc));

   185     

   186     return usbcc;

   187     }

   188 

   189 /**

   190  * FIXME: This function used to be called by the dummy DCD to disable

   191  * the peripheral stack. It has been deprecated and we currently use

   192  * DisablePeripheralStack() to achieve the same effect.

   193  */

   194 EXPORT_C void DUsbClientController::DisableClientStack()

   195     {

   196     __KTRACE_OPT(KUSB, Kern::Printf("CALL TO OBSOLETE FUNCTION: DUsbClientController::DisableClientStack()"));

   197     }

   198 

   199 

   200 /**

   201  * FIXME: This function used to be called by the dummy DCD to enable

   202  * the peripheral stack. It has been deprecated and we currently use

   203  * EnablePeripheralStack() to achieve the same effect.

   204  */

   205 EXPORT_C void DUsbClientController::EnableClientStack()

   206     {

   207     __KTRACE_OPT(KUSB, Kern::Printf("CALL TO OBSOLETE FUNCTION: DUsbClientController::EnableClientStack()"));

   208     }

   209 

   210 

   211 /** Called by LDD to see if controller is usable.

   212 

   213     @return ETrue if controller is in normal state, EFalse if it is disabled.

   214 */

   215 EXPORT_C TBool DUsbClientController::IsActive()

   216     {

   217     __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::IsActive = %d",iStackIsActive));

   218     return iStackIsActive;

   219     }

   220 

   221 

   222 /** Called by LDD to register client callbacks.

   223 

   224     @return KErrNone if successful, KErrAlreadyExists callback exists.

   225 */

   226 EXPORT_C TInt DUsbClientController::RegisterClientCallback(TUsbcClientCallback& aCallback)

   227     {

   228     __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::RegisterClientCallback()"));

   229     if (iClientCallbacks.Elements() == KUsbcMaxListLength)

   230         {

   231         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Maximum list length reached: %d",

   232                                           KUsbcMaxListLength));

   233         return KErrGeneral;

   234         }

   235     TSglQueIter<TUsbcClientCallback> iter(iClientCallbacks);

   236     TUsbcClientCallback* p;

   237     while ((p = iter++) != NULL)

   238         if (p == &aCallback)

   239             {

   240             __KTRACE_OPT(KUSB, Kern::Printf("     Error: ClientCallback @ 0x%x already registered", &aCallback));

   241             return KErrAlreadyExists;

   242             }

   243     iClientCallbacks.AddLast(aCallback);

   244     __KTRACE_OPT(KUSB, Kern::Printf("< DUsbClientController::RegisterClientCallback()"));

   245     return KErrNone;

   246     }

   247 

   248 

   249 /** Returns a pointer to the USB client controller object.

   250 

   251     This function is static.

   252 

   253     @param aUdc The number of the UDC (0..n) for which the pointer is to be returned.

   254 

   255     @return A pointer to the USB client controller object.

   256 */

   257 EXPORT_C DUsbClientController* DUsbClientController::UsbcControllerPointer(TInt aUdc)

   258     {

   259     __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::UsbcControllerPointer()"));

   260     

   261     if (aUdc < 0 || aUdc > 1)

   262         {

   263         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: aUdc out of range (%d)", aUdc));

   264         return NULL;

   265         }

   266         

   267     __KTRACE_OPT(KUSB, Kern::Printf("< DUsbClientController::UsbcControllerPointer()"));

   268     

   269     return UsbClientController[aUdc];

   270     }

   271 

   272 

   273 /** Fills the buffer passed in as an argument with endpoint capability information.

   274 

   275      @see DUsbClientController::DeviceCaps()

   276     @see TUsbcEndpointData

   277     @see TUsbDeviceCaps

   278 

   279     @param aClientId A pointer to the LDD making the enquiry.

   280     @param aCapsBuf A reference to a descriptor buffer, which, on return, contains an array of

   281     TUsbcEndpointData elements; there are TUsbDeviceCaps::iTotalEndpoints elements in the array;

   282     call DeviceCaps() to get the number of elements required.

   283 */

   284 EXPORT_C void DUsbClientController::EndpointCaps(const DBase* aClientId, TDes8& aCapsBuf) const

   285     {

   286     __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::EndpointCaps()"));

   287     // Here we do not simply call DUsbClientController::DeviceEndpointCaps(),

   288     // because that function fills an array which comprises of _all_ endpoints,

   289     // whereas this function omits ep0 and all unusable endpoints.

   290     // Apart from that, we have to fill an array of TUsbcEndpointData, not TUsbcEndpointCaps.

   291     TUsbcEndpointData data[KUsbcMaxEndpoints];

   292     const TInt ifcset_num = ClientId2InterfaceNumber(aClientId);

   293     for (TInt i = 2, j = 0; i < iDeviceTotalEndpoints; ++i)

   294         {

   295         __KTRACE_OPT(KUSB, Kern::Printf("  DUsbClientController::Caps: RealEndpoint #%d", i));

   296         if (iRealEndpoints[i].iCaps.iTypesAndDir != UsbShai::KUsbEpNotAvailable)

   297             {

   298             __KTRACE_OPT(KUSB, Kern::Printf("  DUsbClientController::Caps: --> UsableEndpoint #%d", j));

   299 

   300             data[j].iCaps.iSizes = iRealEndpoints[i].iCaps.iSizes;

   301             data[j].iCaps.iTypesAndDir = iRealEndpoints[i].iCaps.iTypesAndDir;

   302             data[j].iCaps.iHighBandwidth = iRealEndpoints[i].iCaps.iHighBandwidth;

   303             data[j].iCaps.iReserved[0] = iRealEndpoints[i].iCaps.iReserved[0];

   304             data[j].iCaps.iReserved[1] = iRealEndpoints[i].iCaps.iReserved[1];

   305             

   306             if (ifcset_num < 0)

   307                 {

   308                 // If this LDD doesn't own an interface, but the Ep points to one,

   309                 // then that must be the interface of a different LDD. Hence the Ep

   310                 // is not available for this LDD.

   311                 data[j].iInUse = (iRealEndpoints[i].iIfcNumber != NULL);

   312                 }

   313             else

   314                 {

   315                 // If this LDD does already own an interface, and the Ep also points to one,

   316                 // then the Ep is not available for this LDD only if that interface is owned

   317                 // by a different LDD (i.e. if the interface number is different).

   318                 // Reason: Even though the endpoint might already be part of an interface setting,

   319                 // it is still available for a different alternate setting of the same interface.

   320                 data[j].iInUse = ((iRealEndpoints[i].iIfcNumber != NULL) &&

   321                                   (*(iRealEndpoints[i].iIfcNumber) != ifcset_num));

   322                 }

   323 

   324             j++;

   325             }

   326         }

   327     // aCapsBuf resides in userland

   328     TPtrC8 des((TUint8*)data, sizeof(data));

   329     const TInt r = Kern::ThreadDesWrite((reinterpret_cast<const DLddUsbcChannel*>(aClientId))->Client(),

   330                                         &aCapsBuf, des, 0, KChunkShiftBy0, NULL);

   331     if (r != KErrNone)

   332         {

   333         Kern::ThreadKill((reinterpret_cast<const DLddUsbcChannel*>(aClientId))->Client(),

   334                          EExitPanic, r, KUsbPILKillCat);

   335         }

   336         

   337     __KTRACE_OPT(KUSB, Kern::Printf("< DUsbClientController::EndpointCaps()"));

   338     }

   339 

   340 

   341 /** Fills the buffer passed in as an argument with device capability information.

   342 

   343     @see TUsbDeviceCaps

   344     @see TUsbDeviceCapsV01

   345 

   346     @param aClientId A pointer to the LDD making the enquiry.

   347     @param aCapsBuf A reference to a descriptor buffer which, on return, contains

   348     a TUsbDeviceCaps structure.

   349 */

   350 EXPORT_C void DUsbClientController::DeviceCaps(const DBase* aClientId, TDes8& aCapsBuf) const

   351     {

   352     __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::DeviceCaps()"));

   353     TUsbDeviceCaps caps;

   354     caps().iTotalEndpoints = iDeviceUsableEndpoints;        // not DeviceTotalEndpoints()!

   355     

   356     caps().iSelfPowered = iSelfPowered;

   357     caps().iRemoteWakeup = iRemoteWakeup;

   358     caps().iHighSpeed = (iControllerProperties.iControllerCaps & UsbShai::KDevCapHighSpeed)?ETrue:EFalse;

   359     

   360     // PIL always assume controller support this caps, see explaination in peripheral shai header

   361     caps().iFeatureWord1 = caps().iFeatureWord1 | KUsbDevCapsFeatureWord1_CableDetectWithoutPower;

   362     

   363     caps().iFeatureWord1 = caps().iFeatureWord1 | KUsbDevCapsFeatureWord1_EndpointResourceAllocV2;

   364     caps().iReserved = 0;

   365 

   366     // aCapsBuf resides in userland

   367     const TInt r = Kern::ThreadDesWrite((reinterpret_cast<const DLddUsbcChannel*>(aClientId))->Client(),

   368                                         &aCapsBuf, caps, 0, KChunkShiftBy0, NULL);

   369     if (r != KErrNone)

   370         {

   371         Kern::ThreadKill((reinterpret_cast<const DLddUsbcChannel*>(aClientId))->Client(),

   372                          EExitPanic, r, KUsbPILKillCat);

   373         }

   374     __KTRACE_OPT(KUSB, Kern::Printf("< DUsbClientController::DeviceCaps()"));

   375     }

   376 

   377 

   378 TUsbcEndpointInfoArray::TUsbcEndpointInfoArray(const TUsbcEndpointInfo* aData, TInt aDataSize)

   379     {

   380     iType = EUsbcEndpointInfo;

   381     iData = (TUint8*) aData;

   382     if (aDataSize > 0)

   383         iDataSize = aDataSize;

   384     else

   385         iDataSize = sizeof(TUsbcEndpointInfo);

   386     }

   387 

   388 

   389 inline TUsbcEndpointInfo& TUsbcEndpointInfoArray::operator[](TInt aIndex) const

   390     {

   391     return *(TUsbcEndpointInfo*) &iData[aIndex * iDataSize];

   392     }

   393 

   394 

   395 EXPORT_C TInt DUsbClientController::SetInterface(const DBase* aClientId, DThread* aThread,

   396                                                  TInt aInterfaceNum, TUsbcClassInfo& aClass,

   397                                                  TDesC8* aString, TInt aTotalEndpointsUsed,

   398                                                  const TUsbcEndpointInfo aEndpointData[],

   399                                                  TInt (*aRealEpNumbers)[6], TUint32 aFeatureWord)

   400     {

   401     TUsbcEndpointInfoArray endpointData = TUsbcEndpointInfoArray(aEndpointData);

   402     return SetInterface(aClientId, aThread, aInterfaceNum, aClass, aString, aTotalEndpointsUsed,

   403                         endpointData, (TInt*) aRealEpNumbers, aFeatureWord);

   404     }

   405 

   406 

   407 /** Creates a new USB interface (one setting), complete with endpoints, descriptors, etc.,

   408     and chains it into the internal device configuration tree.

   409 

   410     @param aClientId A pointer to the LDD owning the new interface.

   411     @param aThread A pointer to the thread the owning LDD is running in.

   412     @param aInterfaceNum The interface setting number of the new interface setting. This must be 0

   413     if it is the first setting of the interface that gets created, or 1 more than the last setting

   414     that was created for this interface.

   415     @param aClass Contains information about the device class this interface might belong to.

   416     @param aString A pointer to a string that is used for the string descriptor of this interface.

   417     @param aTotalEndpointsUsed The number of endpoints used by this interface (and also the number of

   418     elements of the following array).

   419     @param aEndpointData An array with aTotalEndpointsUsed elements, containing information about the

   420     endpoints of this interface.

   421 

   422     @return KErrNotSupported if Control endpoints are requested by the LDD but aren't supported by the PIL,

   423     KErrInUse if at least one requested endpoint is - temporarily or permanently - not available for use,

   424     KErrNoMemory if (endpoint, interface, string) descriptor allocation fails, KErrGeneral if something else

   425     goes wrong during endpoint or interface or descriptor creation, KErrNone if interface successfully set up.

   426 */

   427 EXPORT_C TInt DUsbClientController::SetInterface(const DBase* aClientId, DThread* aThread,

   428                                                  TInt aInterfaceNum, TUsbcClassInfo& aClass,

   429                                                  TDesC8* aString, TInt aTotalEndpointsUsed,

   430                                                  const TUsbcEndpointInfoArray aEndpointData,

   431                                                  TInt aRealEpNumbers[], TUint32 aFeatureWord)

   432     {

   433     __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::SetInterface()"));

   434     if (aInterfaceNum != 0)

   435         {

   436         __KTRACE_OPT(KUSB, Kern::Printf("  alternate interface setting request: #%d", aInterfaceNum));

   437         }

   438 

   439 #ifndef USB_SUPPORTS_CONTROLENDPOINTS

   440     for (TInt i = 0; i < aTotalEndpointsUsed; ++i)

   441         {

   442         if (aEndpointData[i].iType == UsbShai::KUsbEpTypeControl)

   443             {

   444             __KTRACE_OPT(KPANIC, Kern::Printf("  Error: control endpoints not supported"));

   445             return KErrNotSupported;

   446             }

   447         }

   448 #endif

   449 

   450     // Check for endpoint availability & check those endpoint's capabilities

   451     const TInt ifcset_num = ClientId2InterfaceNumber(aClientId);

   452     

   453     // The passed-in ifcset_num may be -1 now, but that's intended.

   454     if (!CheckEpAvailability(aTotalEndpointsUsed, aEndpointData, ifcset_num))

   455         {

   456         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: endpoints not (all) available"));

   457         return KErrInUse;

   458         }

   459     

   460     // Create & setup new interface

   461     TUsbcInterface* ifc = CreateInterface(aClientId, aInterfaceNum, aFeatureWord);

   462     if (ifc == NULL)

   463         {

   464         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: ifc == NULL"));

   465         return KErrGeneral;

   466         }

   467     

   468     // Create logical endpoints

   469     TInt r = CreateEndpoints(ifc, aTotalEndpointsUsed, aEndpointData, aRealEpNumbers);

   470     if (r != KErrNone)

   471         {

   472         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: CreateEndpoints() err = %d ",r));

   473         DeleteInterface(ifc->iInterfaceSet->iInterfaceNumber, aInterfaceNum);

   474         return r;

   475         }

   476     

   477     // Create & setup interface, string, and endpoint descriptors

   478     r = SetupIfcDescriptor(ifc, aClass, aThread, aString, aEndpointData);

   479     if (r != KErrNone)

   480         {

   481         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: SetupIfcDescriptor() err = %d",r));

   482         return r;

   483         }

   484     

   485     __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::SetInterface()"));

   486     return KErrNone;

   487     }

   488 

   489 

   490 /** Releases an existing USB interface (one setting), complete with endpoints, descriptors, etc.,

   491     and removes it from the internal device configuration tree.

   492 

   493     @param aClientId A pointer to the LDD owning the interface.

   494     @param aInterfaceNum The setting number of the interface setting to be deleted. This must be

   495     the highest numbered (or 'last') setting for this interface.

   496 

   497     @return KErrNotFound if interface (not setting) for some reason cannot be found, KErrArgument if an

   498     invalid interface setting number is specified (not existing or existing but too small), KErrNone if

   499     interface successfully released or if this client doesn't own any interface.

   500 */

   501 EXPORT_C TInt DUsbClientController::ReleaseInterface(const DBase* aClientId, TInt aInterfaceNum)

   502     {

   503     __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::ReleaseInterface(..., %d)", aInterfaceNum));

   504     const TInt ifcset = ClientId2InterfaceNumber(aClientId);

   505     if (ifcset < 0)

   506         {

   507         __KTRACE_OPT(KUSB, Kern::Printf("  interface not found")); // no error

   508         return KErrNone;

   509         }

   510     TUsbcInterfaceSet* const ifcset_ptr = InterfaceNumber2InterfacePointer(ifcset);

   511     if (!ifcset_ptr)

   512         {

   513         __KTRACE_OPT(KUSB, Kern::Printf("  Error: interface number %d doesn't exist", ifcset));

   514         return KErrNotFound;

   515         }

   516     const TInt setting_count = ifcset_ptr->iInterfaces.Count();

   517     if ((setting_count - 1) != aInterfaceNum)

   518         {

   519         __KTRACE_OPT(KUSB,

   520                      Kern::Printf("  Error: interface settings must be released in descending order:\n\r"

   521                                   "   %d setting(s) exist, #%d was requested to be released.\n\r"

   522                                   "   (#%d has to be released first)",

   523                                   setting_count, aInterfaceNum, setting_count - 1));

   524         return KErrArgument;

   525         }

   526     // Tear down current setting (invalidate configured state)

   527     __KTRACE_OPT(KUSB, Kern::Printf("  tearing down InterfaceSet %d", ifcset));

   528     // Cancel all transfers on the current setting of this interface and deconfigure all its endpoints.

   529     InterfaceSetTeardown(ifcset_ptr);

   530     // 'Setting 0' means: delete all existing settings.

   531     if (aInterfaceNum == 0)

   532         {

   533         TInt m = ifcset_ptr->iInterfaces.Count();

   534         while (m > 0)

   535             {

   536             m--;

   537             // Ground the physical endpoints' logical_endpoint_pointers

   538             const TInt n = ifcset_ptr->iInterfaces[m]->iEndpoints.Count();

   539             for (TInt i = 0; i < n; ++i)

   540                 {

   541                 TUsbcPhysicalEndpoint* ptr = const_cast<TUsbcPhysicalEndpoint*>

   542                     (ifcset_ptr->iInterfaces[m]->iEndpoints[i]->iPEndpoint);

   543                 ptr->iLEndpoint = NULL;

   544                 }

   545             // Delete the setting itself + its ifc & ep descriptors

   546             DeleteInterface(ifcset, m);

   547             iDescriptors.DeleteIfcDescriptor(ifcset, m);

   548             }

   549         }

   550     else

   551         {

   552         // Ground the physical endpoints' logical_endpoint_pointers

   553         const TInt n = ifcset_ptr->iInterfaces[aInterfaceNum]->iEndpoints.Count();

   554         for (TInt i = 0; i < n; ++i)

   555             {

   556             TUsbcPhysicalEndpoint* ptr = const_cast<TUsbcPhysicalEndpoint*>

   557                 (ifcset_ptr->iInterfaces[aInterfaceNum]->iEndpoints[i]->iPEndpoint);

   558             ptr->iLEndpoint = NULL;

   559             }

   560         // Delete the setting itself + its ifc & ep descriptors

   561         DeleteInterface(ifcset, aInterfaceNum);

   562         iDescriptors.DeleteIfcDescriptor(ifcset, aInterfaceNum);

   563         }

   564     // Delete the whole interface if all settings are gone

   565     if (ifcset_ptr->iInterfaces.Count() == 0)

   566         {

   567         DeleteInterfaceSet(ifcset);

   568         }

   569     // We now no longer have a valid current configuration

   570     iCurrentConfig = 0;

   571     if (iDeviceState == UsbShai::EUsbPeripheralStateConfigured)

   572         {

   573         NextDeviceState(UsbShai::EUsbPeripheralStateAddress);

   574         }

   575     // If it was the last interface(set)...

   576     if (iConfigs[0]->iInterfaceSets.Count() == 0)

   577         {

   578         __KTRACE_OPT(KUSB, Kern::Printf("  No ifc left -> turning off UDC"));

   579         // First disconnect the device from the bus

   580         UsbDisconnect();

   581         DeActivateHardwareController();

   582         // (this also disables endpoint zero; we cannot have a USB device w/o interface, see 9.6.3)

   583         }

   584     __KTRACE_OPT(KUSB, Kern::Printf("< DUsbClientController::ReleaseInterface"));

   585     return KErrNone;

   586     }

   587 

   588 

   589 /** Enforces a USB re-enumeration by disconnecting the UDC from the bus (if it is currently connected) and

   590     re-connecting it.

   591 

   592     This only works if the PSL supports it, i.e. if SoftConnectCaps() returns ETrue.

   593 */

   594 EXPORT_C TInt DUsbClientController::ReEnumerate()

   595     {

   596     __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::ReEnumerate()"));

   597     

   598     // ReEnumerate is possible only when stack is enabled

   599     if (!iStackIsActive)

   600         {

   601         __KTRACE_OPT(KUSB, Kern::Printf("  Client stack disabled -> returning here"));

   602         return KErrNotReady;

   603         }

   604     

   605     // If no interfaces setup, there is no point to reenumerate

   606     if (iConfigs[0]->iInterfaceSets.Count() == 0)

   607         {

   608         __KTRACE_OPT(KUSB, Kern::Printf("  > No interface registered -> no need to re-enumerate"));

   609         return KErrNone;;

   610         }

   611     

   612     if (!iHardwareActivated)

   613         {

   614         // If the UDC is still off, we switch it on here.

   615         const TInt r = ActivateHardwareController();

   616         if (r != KErrNone)

   617                 {

   618                 __KTRACE_OPT(KPANIC, Kern::Printf("  Error: ActivateHardwareController() failed: %d", r));

   619                 return r;

   620                 }

   621         

   622         // Finally connect the device to the bus

   623         UsbConnect();

   624         }

   625     else

   626         {

   627         UsbDisconnect();

   628         

   629         // Now we have to wait a certain amount of time, in order to give the host the opportunity

   630         // to come to terms with the new situation.

   631         // (The ETrue parameter makes the callback get called in DFC instead of in ISR context.)

   632         iReconnectTimer.OneShot(KUsbReconnectDelay, ETrue);

   633         }

   634         

   635     __KTRACE_OPT(KUSB, Kern::Printf("< DUsbClientController::ReEnumerate()"));

   636     return KErrNone;;

   637     }

   638 

   639 

   640 /** Powers up the UDC if one or more interfaces exist.

   641 

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

   643     interfaces have been registered yet, KErrHardwareNotAvailable if UDC

   644     couldn't be activated.

   645 */

   646 EXPORT_C TInt DUsbClientController::PowerUpUdc()

   647     {

   648     __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::PowerUpUdc()"));

   649     

   650     // we need to check whether Stack is activate or not(can be done by otg sw in otg setup

   651     // or by vBus risen/fallen event in a non-otg env)

   652     if (!iStackIsActive)

   653         {

   654         __KTRACE_OPT(KUSB, Kern::Printf("  Client stack disabled -> returning here"));

   655         return KErrNotReady;

   656         }

   657     

   658     if (iConfigs[0]->iInterfaceSets.Count() == 0)

   659         {

   660         __KTRACE_OPT(KUSB, Kern::Printf("  No interface registered -> won't power up UDC"));

   661         return KErrNotReady;

   662         }

   663     

   664     // If the UDC is still off, we switch it on here.

   665     const TInt r = ActivateHardwareController();

   666     if (r != KErrNone)

   667         {

   668         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: ActivateHardwareController() failed: %d", r));

   669         }

   670     

   671     __KTRACE_OPT(KUSB, Kern::Printf("< DUsbClientController::PowerUpUdc() returns %d",r));

   672     return r;

   673     }

   674 

   675 

   676 /** Connects the UDC to the bus.

   677 

   678     @return KErrNone if UDC successfully connected, 

   679             KErrNotSupported if KDevCapSoftConnect not supported

   680             KErrGeneral if there was an error.

   681             

   682 */

   683 EXPORT_C TInt DUsbClientController::UsbConnect()

   684     {

   685     __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::UsbConnect()"));

   686     iClientSupportReady = ETrue;

   687     

   688     // If a deferred reset is pending, service it now

   689     const TInt irq = __SPIN_LOCK_IRQSAVE(iUsbLock);

   690     if (iUsbResetDeferred)

   691         {

   692         __KTRACE_OPT(KUSB, Kern::Printf("  Resetting USB Reset 'defer' flag"));

   693         iUsbResetDeferred = EFalse;

   694         (void) ProcessResetEvent(EFalse);

   695         }

   696     __SPIN_UNLOCK_IRQRESTORE(iUsbLock, irq);

   697 

   698     // Indicate readiness to connect to the PSL

   699     const TInt r = iController.PeripheralConnect();

   700     

   701     // Check whether Stack is activated by OTG controller

   702     // or Vbus Risen had been detected.

   703     // If either of them is true and HW is not activated yet, do it here.

   704     if (iStackIsActive &&  !iHardwareActivated )

   705         {

   706         // PowerUpUdc only do Activating Hardware when there are at least 1

   707         // Iterface registered            

   708         PowerUpUdc();

   709         }

   710     

   711     __KTRACE_OPT(KUSB, Kern::Printf("< DUsbClientController::UsbConnect()"));

   712     return r;

   713     }

   714 

   715 

   716 /** Disconnects the UDC from the bus.

   717 

   718     This only works if the PSL supports it, i.e. if SoftConnectCaps() returns ETrue.

   719 

   720     @return KErrNone if UDC successfully disconnected, KErrGeneral if there was an error.

   721 */

   722 EXPORT_C TInt DUsbClientController::UsbDisconnect()

   723     {

   724     __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::UsbDisconnect()"));

   725     iClientSupportReady = EFalse;

   726 

   727     // Indicate to PSL that we are no longer ready to connect

   728     const TInt r = iController.PeripheralDisconnect();

   729 

   730     // There won't be any notification by the PSL about this,

   731     // so we have to notify the LDD/user ourselves:

   732     if ((r == KErrNone) && (iDeviceState != UsbShai::EUsbPeripheralStateUndefined))

   733         {

   734         // Not being in state UNDEFINED implies that the cable is inserted.

   735         if (iHardwareActivated)

   736             {

   737             NextDeviceState(UsbShai::EUsbPeripheralStatePowered);

   738             }

   739         // (If the hardware is NOT activated at this point, we can only be in

   740         //    state UsbShai::EUsbPeripheralStateAttached, so we don't have to move to it.)

   741         }

   742     return r;

   743     }

   744 

   745 

   746 /** Registers a notification callback for changes of the USB device state.

   747 

   748     In the event of a device state change, the callback's state member gets updated (using SetState) with a

   749     new UsbShai::TUsbPeripheralState value, and then the callback is executed (DoCallback). 'USB device state' here refers

   750     to the Visible Device States as defined in chapter 9 of the USB specification.

   751 

   752     @param aCallback A reference to a properly filled in status callback structure.

   753 

   754     @return KErrNone if callback successfully registered, KErrGeneral if this callback is already registered

   755     (it won't be registered twice).

   756 */

   757 EXPORT_C TInt DUsbClientController::RegisterForStatusChange(TUsbcStatusCallback& aCallback)

   758     {

   759     __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::RegisterForStatusChange()"));

   760     if (iStatusCallbacks.Elements() == KUsbcMaxListLength)

   761         {

   762         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Maximum list length reached: %d",

   763                                           KUsbcMaxListLength));

   764         return KErrGeneral;

   765         }

   766     if (IsInTheStatusList(aCallback))

   767         {

   768         __KTRACE_OPT(KUSB, Kern::Printf("  Error: StatusCallback @ 0x%x already registered", &aCallback));

   769         return KErrGeneral;

   770         }

   771     const TInt irq = __SPIN_LOCK_IRQSAVE(iUsbLock);

   772     iStatusCallbacks.AddLast(aCallback);

   773     __SPIN_UNLOCK_IRQRESTORE(iUsbLock, irq);

   774     return KErrNone;

   775     }

   776 

   777 

   778 /** De-registers (removes from the list of pending requests) a notification callback for the USB device

   779     status.

   780 

   781     @param aClientId A pointer to the LDD owning the status change callback.

   782 

   783     @return KErrNone if callback successfully unregistered, KErrNotFound if the callback couldn't be found.

   784 */

   785 EXPORT_C TInt DUsbClientController::DeRegisterForStatusChange(const DBase* aClientId)

   786     {

   787     __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::DeRegisterForStatusChange()"));

   788     __ASSERT_DEBUG((aClientId != NULL), Kern::Fault(KUsbPILPanicCat, __LINE__));

   789     const TInt irq = __SPIN_LOCK_IRQSAVE(iUsbLock);

   790     TSglQueIter<TUsbcStatusCallback> iter(iStatusCallbacks);

   791     TUsbcStatusCallback* p;

   792     while ((p = iter++) != NULL)

   793         {

   794         if (p->Owner() == aClientId)

   795             {

   796             __KTRACE_OPT(KUSB, Kern::Printf("  removing StatusCallback @ 0x%x", p));

   797             iStatusCallbacks.Remove(*p);

   798             __SPIN_UNLOCK_IRQRESTORE(iUsbLock, irq);

   799             return KErrNone;

   800             }

   801         }

   802     __KTRACE_OPT(KUSB, Kern::Printf("  client not found"));

   803     __SPIN_UNLOCK_IRQRESTORE(iUsbLock, irq);

   804     return KErrNotFound;

   805     }

   806 

   807 

   808 /** Registers a notification callback for changes of the state of endpoints.

   809 

   810     In the event of a state change of an endpoint that is spart of an interface which is owned by the LDD

   811     specified in the callback structure, the callback's state member gets updated (using SetState) with a new

   812     value, and the callback is executed (DoCallback). 'Endpoint state' here refers to the state of the

   813     ENDPOINT_HALT feature of an endpoint as described in chapter 9 of the USB specification. The contents of

   814     the state variable reflects the state of the halt features for all endpoints of the current interface

   815     setting: bit 0 represents endpoint 1, bit 1 endpoint 2, etc. A set bit means 'endpoint halted', a cleared

   816     bit 'endpoint not halted'.

   817 

   818     @param aCallback A reference to a properly filled in endpoint status callback structure.

   819 

   820     @return KErrNone if callback successfully registered, KErrGeneral if this callback is already registered

   821     (it won't be registered twice).

   822 */

   823 EXPORT_C TInt DUsbClientController::RegisterForEndpointStatusChange(TUsbcEndpointStatusCallback& aCallback)

   824     {

   825     __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::RegisterForEndpointStatusChange()"));

   826     if (iEpStatusCallbacks.Elements() == KUsbcMaxListLength)

   827         {

   828         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Maximum list length reached: %d",

   829                                           KUsbcMaxListLength));

   830         return KErrGeneral;

   831         }

   832     if (IsInTheEpStatusList(aCallback))

   833         {

   834         __KTRACE_OPT(KUSB, Kern::Printf("  Error: EpStatusCallback @ 0x%x already registered", &aCallback));

   835         return KErrGeneral;

   836         }

   837     const TInt irq = __SPIN_LOCK_IRQSAVE(iUsbLock);

   838     iEpStatusCallbacks.AddLast(aCallback);

   839     __SPIN_UNLOCK_IRQRESTORE(iUsbLock, irq);

   840     return KErrNone;

   841     }

   842 

   843 

   844 /** De-registers (removes from the list of pending requests) a notification callback for changes of the state

   845     of endpoints.

   846 

   847     @param aClientId A pointer to the LDD owning the endpoint status change callback.

   848 

   849     @return KErrNone if callback successfully unregistered, KErrNotFound if the callback couldn't be found.

   850 */

   851 EXPORT_C TInt DUsbClientController::DeRegisterForEndpointStatusChange(const DBase* aClientId)

   852     {

   853     __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::DeRegisterForEndpointStatusChange()"));

   854     __ASSERT_DEBUG((aClientId != NULL), Kern::Fault(KUsbPILPanicCat, __LINE__));

   855     const TInt irq = __SPIN_LOCK_IRQSAVE(iUsbLock);

   856     TSglQueIter<TUsbcEndpointStatusCallback> iter(iEpStatusCallbacks);

   857     TUsbcEndpointStatusCallback* p;

   858     while ((p = iter++) != NULL)

   859         {

   860         if (p->Owner() == aClientId)

   861             {

   862             __KTRACE_OPT(KUSB, Kern::Printf("  removing EpStatusCallback @ 0x%x", p));

   863             iEpStatusCallbacks.Remove(*p);

   864             __SPIN_UNLOCK_IRQRESTORE(iUsbLock, irq);

   865             return KErrNone;

   866             }

   867         }

   868     __KTRACE_OPT(KUSB, Kern::Printf("  client not found"));

   869     __SPIN_UNLOCK_IRQRESTORE(iUsbLock, irq);

   870     return KErrNotFound;

   871     }

   872 

   873 

   874 /** Returns the number of the currently active alternate interface setting for this interface.

   875 

   876     @param aClientId A pointer to the LDD owning the interface.

   877     @param aInterfaceNum Here the interface gets written to.

   878 

   879     @return KErrNotFound if an interface for this client couldn't be found, KErrNone if setting value was

   880     successfully written.

   881 */

   882 EXPORT_C TInt DUsbClientController::GetInterfaceNumber(const DBase* aClientId, TInt& aInterfaceNum) const

   883     {

   884     __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::GetInterfaceNumber()"));

   885     const TInt ifcset = ClientId2InterfaceNumber(aClientId);

   886     if (ifcset < 0)

   887         {

   888         __KTRACE_OPT(KPANIC, Kern::Printf("  Error (ifc < 0)"));

   889         return KErrNotFound;

   890         }

   891     const TUsbcInterfaceSet* const ifcset_ptr = InterfaceNumber2InterfacePointer(ifcset);

   892     if (!ifcset_ptr)

   893         {

   894         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: interface number %d doesn't exist", ifcset));

   895         return KErrNotFound;

   896         }

   897     aInterfaceNum = ifcset_ptr->iCurrentInterface;

   898     return KErrNone;

   899     }

   900 

   901 

   902 /** This is normally called once by an LDD's destructor, either after a Close() on the user side,

   903     or during general cleanup.

   904 

   905     It might also be called by the LDD when some internal unrecoverable error occurs.

   906 

   907     This function

   908     - de-registers a possibly pending device state change notification request,

   909     - de-registers a possibly pending endpoint state change notification request,

   910     - releases all interfaces + settings owned by this LDD,

   911     - cancels all remaining (if any) read/write requests.

   912 

   913     @param aClientId A pointer to the LDD to be unregistered.

   914 

   915     @return KErrNone.

   916 */

   917 EXPORT_C TInt DUsbClientController::DeRegisterClient(const DBase* aClientId)

   918     {

   919     __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::DeRegisterClient(0x%x)", aClientId));

   920     // Cancel all device state notification requests

   921     DeRegisterForStatusChange(aClientId);

   922     // Cancel all endpoint state notification requests

   923     DeRegisterForEndpointStatusChange(aClientId);

   924     DeRegisterForOtgFeatureChange(aClientId);

   925     DeRegisterClientCallback(aClientId);

   926     // Delete the interface including all its alternate settings which might exist.

   927     // (If we release the default setting (0), all alternate settings are deleted as well.)

   928     const TInt r = ReleaseInterface(aClientId, 0);

   929     // Cancel all remaining (if any) read/write requests

   930     DeleteRequestCallbacks(aClientId);

   931     __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::DeRegisterClient: Done."));

   932     return r;

   933     }

   934 

   935 

   936 /** Returns the currently used Ep0 max packet size.

   937 

   938     @return The currently used Ep0 max packet size.

   939 */

   940 EXPORT_C TInt DUsbClientController::Ep0PacketSize() const

   941     {

   942     const TUsbcLogicalEndpoint* const ep = iRealEndpoints[0].iLEndpoint;

   943     if (iHighSpeed)

   944         {

   945         __KTRACE_OPT(KUSB, Kern::Printf("  Ep0 size = %d (HS)", ep->iEpSize_Hs));

   946         return ep->iEpSize_Hs;

   947         }

   948     else

   949         {

   950         __KTRACE_OPT(KUSB, Kern::Printf("  Ep0 size = %d (FS)", ep->iEpSize_Fs));

   951         return ep->iEpSize_Fs;

   952         }

   953     }

   954 

   955 

   956 /** Stalls Ep0.

   957 

   958     @param aClientId A pointer to the LDD wishing to stall Ep0 (this is for PIL internal purposes only).

   959 

   960     @return KErrNone if endpoint zero successfully stalled, KErrGeneral otherwise.

   961 */

   962 EXPORT_C TInt DUsbClientController::Ep0Stall(const DBase* aClientId)

   963     {

   964     __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::Ep0Stall()"));

   965     if (aClientId == iEp0ClientId)

   966         {

   967         ResetEp0DataOutVars();

   968         }

   969     const TInt err = iConTransferMgr->StallEndpoint(KEp0_Out);

   970     if (err < 0)

   971         {

   972         return err;

   973         }

   974     else

   975         return iConTransferMgr->StallEndpoint(KEp0_In);

   976     }

   977 

   978 

   979 /** Sends a zero-byte status packet on Ep0.

   980 

   981     @param aClientId A pointer to the LDD wishing to send the status packet (not used at present).

   982 */

   983 EXPORT_C void DUsbClientController::SendEp0StatusPacket(const DBase* /* aClientId */)

   984     {

   985     __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::SendEp0StatusPacket()"));

   986     iConTransferMgr->SendEp0ZeroByteStatusPacket();

   987     }

   988 

   989 

   990 /** Returns the current USB device state.

   991 

   992     'USB device state' here refers to the Visible Device States as defined in chapter 9 of the USB

   993     specification.

   994 

   995     @return The current USB device state, or UsbShai::EUsbPeripheralStateUndefined

   996 */

   997 EXPORT_C UsbShai::TUsbPeripheralState DUsbClientController::GetDeviceStatus() const

   998     {

   999     __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::GetDeviceStatus()"));

  1000     return iDeviceState;

  1001     }

  1002 

  1003 

  1004 /** Returns the state of an endpoint.

  1005 

  1006     'Endpoint state' here refers to the state of the ENDPOINT_HALT feature of

  1007     an endpoint as described in chapter 9 of the USB specification.

  1008 

  1009     @param aClientId A pointer to the LDD owning the interface which contains the endpoint to be queried.

  1010     @param aEndpointNum The number of the endpoint to be queried.

  1011 

  1012     @return The current endpoint state, or EEndpointStateUnknown if the endpoint couldn't be found.

  1013 */

  1014 EXPORT_C TEndpointState DUsbClientController::GetEndpointStatus(const DBase* aClientId, TInt aEndpointNum) const

  1015     {

  1016     __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::GetEndpointStatus()"));

  1017     

  1018     TEndpointState ret = (iRealEndpoints[aEndpointNum].iHalt)?EEndpointStateStalled : EEndpointStateNotStalled;

  1019     

  1020     __KTRACE_OPT(KUSB, Kern::Printf("< DUsbClientController::GetEndpointStatus() %d",ret));

  1021     

  1022     return  ret;

  1023     }

  1024 

  1025 

  1026 /** Sets up a data read request for an endpoint.

  1027 

  1028     @param aCallback A reference to a properly filled in data transfer request callback structure.

  1029 

  1030     @return KErrNone if callback successfully registered or if this callback is already registered

  1031     (but it won't be registered twice), KErrNotFound if the endpoint couldn't be found, KErrArgument if

  1032     endpoint number invalid (PSL), KErrGeneral if something else goes wrong.

  1033 */

  1034 EXPORT_C TInt DUsbClientController::SetupReadBuffer(TUsbcRequestCallback& aCallback)

  1035     {

  1036     __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::SetupReadBuffer()"));

  1037     const TInt ep = aCallback.iRealEpNum;

  1038     __KTRACE_OPT(KUSB, Kern::Printf("  logical ep: #%d", aCallback.iEndpointNum));

  1039     __KTRACE_OPT(KUSB, Kern::Printf("  real ep:    #%d", ep));

  1040     TInt err = KErrGeneral;

  1041     if (ep != 0)

  1042         {

  1043         if (iRequestCallbacks[ep])

  1044             {

  1045             __KTRACE_OPT(KPANIC, Kern::Printf("  Warning: RequestCallback already registered for that ep"));

  1046             if (iRequestCallbacks[ep] == &aCallback)

  1047                 {

  1048                 __KTRACE_OPT(KPANIC, Kern::Printf("  (this same RequestCallback @ 0x%x)", &aCallback));

  1049                 }

  1050             else

  1051                 {

  1052                 __KTRACE_OPT(KPANIC, Kern::Printf("  (a different RequestCallback @ 0x%x)", &aCallback));

  1053                 }

  1054             return KErrNone;

  1055             }

  1056         // This may seem awkward:

  1057         // First we add a callback, and then, in case of an error, we remove it again.

  1058         // However this is necessary because the transfer request might complete (through

  1059         // an ISR) _before_ the SetupEndpointRead function returns. Since we don't know the

  1060         // outcome, we have to provide the callback before making the setup call.

  1061         //

  1062         __KTRACE_OPT(KUSB, Kern::Printf("  adding RequestCallback[%d] @ 0x%x", ep, &aCallback));

  1063         iRequestCallbacks[ep] = &aCallback;

  1064         if ((err = iController.SetupEndpointRead(ep, aCallback)) != KErrNone)

  1065             {

  1066             __KTRACE_OPT(KPANIC, Kern::Printf("  removing RequestCallback @ 0x%x (due to error)",

  1067                                               &aCallback));

  1068             iRequestCallbacks[ep] = NULL;

  1069             }

  1070         }

  1071     else                                                    // (ep == 0)

  1072         {

  1073         if (iEp0ReadRequestCallbacks.Elements() == KUsbcMaxListLength)

  1074             {

  1075             __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Maximum list length reached: %d",

  1076                                               KUsbcMaxListLength));

  1077             return KErrGeneral;

  1078             }

  1079         if (IsInTheRequestList(aCallback))

  1080             {       

  1081             __KTRACE_OPT(KUSB, Kern::Printf("  RequestCallback @ 0x%x already registered", &aCallback));

  1082             return KErrNone;

  1083             }

  1084         // Ep0 reads don't need to be prepared - there's always one pending

  1085         __KTRACE_OPT(KUSB, Kern::Printf("  adding RequestCallback @ 0x%x (ep0)", &aCallback));

  1086         const TInt irq = __SPIN_LOCK_IRQSAVE(iUsbLock);

  1087         iEp0ReadRequestCallbacks.AddLast(aCallback);

  1088         __SPIN_UNLOCK_IRQRESTORE(iUsbLock, irq);

  1089         err = KErrNone;

  1090         if (iEp0_RxExtraCount != 0)

  1091             {

  1092             __KTRACE_OPT(KUSB, Kern::Printf("  iEp0_RxExtraData: trying again..."));

  1093             

  1094             const TInt irq = __SPIN_LOCK_IRQSAVE(iUsbLock);

  1095             

  1096             // Extra data is either a setup packet or a data packet

  1097             // They are not possible to be both

  1098             // And, the error code must be KErrNone, otherwise, we can not arrive here

  1099             if( iSetupPacketPending )

  1100                 {

  1101                 ProcessSetupPacket(iEp0_RxExtraCount,KErrNone);

  1102                 }

  1103             else

  1104                 {

  1105                 ProcessDataOutPacket(iEp0_RxExtraCount,KErrNone);

  1106                 }

  1107             

  1108             // clear it since already completed to client

  1109             iEp0_RxExtraCount = 0;

  1110             

  1111             err = iLastError;

  1112             

  1113             __SPIN_UNLOCK_IRQRESTORE(iUsbLock, irq);

  1114             if (err == KErrNone)

  1115                 {

  1116                 //iEp0_RxExtraData = EFalse;

  1117                 // Queue a new Ep0 read (because xxxProceed only re-enables the interrupt)

  1118                 iConTransferMgr->SetupEndpointZeroRead();

  1119                 if (iSetupPacketPending)

  1120                     {

  1121                     iConTransferMgr->Ep0SetupPacketProceed();

  1122                     iSetupPacketPending = EFalse;

  1123                     }

  1124                 else

  1125                     {

  1126                     iConTransferMgr->Ep0DataPacketProceed();

  1127                     }

  1128                 

  1129                 __KTRACE_OPT(KUSB, Kern::Printf("  :-)"));

  1130                 }

  1131             else

  1132                 {

  1133                 __KTRACE_OPT(KPANIC, Kern::Printf("  Error: :-("));

  1134                 err = KErrGeneral;