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/usbc/d_usbc.cpp

    15 // LDD for USB Device driver stack:

    16 // The channel object.

    17 // 

    18 //

    19 

    20 /**

    21  @file d_usbc.cpp

    22  @internalTechnology

    23 */

    24 

    25 #include <usb/usbc.h>

    26 

    27 

    28 _LIT(KUsbLddName, "Usbc");

    29 

    30 static const TInt KUsbRequestCallbackPriority = 2;

    31 

    32 

    33 // Quick sanity check on endpoint properties

    34 static TBool ValidateEndpoint(const TUsbcEndpointInfo* aEndpointInfo)

    35     {

    36     const TUint dir = aEndpointInfo->iDir;

    37     const TInt size = aEndpointInfo->iSize;

    38     if (size <= 0)

    39         return EFalse;

    40 

    41     switch (aEndpointInfo->iType)

    42         {

    43     case UsbShai::KUsbEpTypeControl:

    44         if (dir != UsbShai::KUsbEpDirBidirect || size > 64)

    45             return EFalse;

    46         break;

    47     case UsbShai::KUsbEpTypeIsochronous:

    48         if ((dir != UsbShai::KUsbEpDirIn && dir != UsbShai::KUsbEpDirOut) || size > 1024)

    49             return EFalse;

    50         break;

    51     case UsbShai::KUsbEpTypeBulk:

    52         if ((dir != UsbShai::KUsbEpDirIn && dir != UsbShai::KUsbEpDirOut) || size > 512)

    53             return EFalse;

    54         break;

    55     case UsbShai::KUsbEpTypeInterrupt:

    56         if ((dir != UsbShai::KUsbEpDirIn && dir != UsbShai::KUsbEpDirOut) || size > 1024)

    57             return EFalse;

    58         break;

    59     default:

    60         return EFalse;

    61         }

    62     return ETrue;

    63     }

    64 

    65 

    66 /** Real entry point from the Kernel: return a new driver.

    67  */

    68 DECLARE_STANDARD_LDD()

    69     {

    70     return new DUsbcLogDevice;

    71     }

    72 

    73 

    74 /** Create a channel on the device.

    75 

    76     @internalComponent

    77 */

    78 TInt DUsbcLogDevice::Create(DLogicalChannelBase*& aChannel)

    79     {

    80     aChannel = new DLddUsbcChannel;

    81     return aChannel ? KErrNone : KErrNoMemory;

    82     }

    83 

    84 

    85 DUsbcLogDevice::DUsbcLogDevice()

    86       {

    87       iParseMask = KDeviceAllowUnit;

    88       iUnitsMask = 0xffffffff;                                // Leave units decision to the Controller

    89       iVersion = TVersion(KUsbcMajorVersion, KUsbcMinorVersion, KUsbcBuildVersion);

    90       }

    91 

    92 

    93 TInt DUsbcLogDevice::Install()

    94     {

    95     // Only proceed if we have the Controller underneath us

    96     if (!DUsbClientController::UsbcControllerPointer())

    97         {

    98         __KTRACE_OPT(KPANIC, Kern::Printf("LDD Install: USB Controller Not Present"));

    99         return KErrGeneral;

   100         }

   101     return SetName(&KUsbLddName);

   102     }

   103 

   104 

   105 //

   106 // Return the USB controller capabilities.

   107 //

   108 void DUsbcLogDevice::GetCaps(TDes8& aDes) const

   109     {

   110     TPckgBuf<TCapsDevUsbc> b;

   111     b().version = iVersion;

   112     Kern::InfoCopy(aDes, b);

   113     }

   114 

   115 

   116 //

   117 // Constructor

   118 //

   119 DLddUsbcChannel::DLddUsbcChannel()

   120     : iValidInterface(EFalse),

   121       iAlternateSettingList(NULL),

   122       iCompleteAllCallbackInfo(this, DLddUsbcChannel::EmergencyCompleteDfc, KUsbRequestCallbackPriority),

   123       iStatusChangePtr(NULL),

   124       iStatusCallbackInfo(this, DLddUsbcChannel::StatusChangeCallback, KUsbRequestCallbackPriority),

   125       iEndpointStatusChangePtr(NULL),

   126       iEndpointStatusCallbackInfo(this, DLddUsbcChannel::EndpointStatusChangeCallback,

   127                                   KUsbRequestCallbackPriority),

   128       iOtgFeatureChangePtr(NULL),

   129       iOtgFeatureCallbackInfo(this, DLddUsbcChannel::OtgFeatureChangeCallback, KUsbRequestCallbackPriority),

   130       iNumberOfEndpoints(0),

   131       iDeviceState(UsbShai::EUsbPeripheralStateUndefined),

   132       iOwnsDeviceControl(EFalse),

   133       iAlternateSetting(0),

   134       iDeviceStatusNeeded(EFalse),

   135       iChannelClosing(EFalse)

   136     {

   137     __KTRACE_OPT(KUSB, Kern::Printf("*** DLddUsbcChannel::DLddUsbcChannel CTOR"));

   138     iClient = &Kern::CurrentThread();

   139     iClient->Open();

   140     for (TInt i = 1; i <= KMaxEndpointsPerClient; i++)

   141         {

   142         iEndpoint[i] = NULL;

   143         }

   144     for (TInt i = 1; i < KUsbcMaxRequests; i++)

   145         {

   146         iRequestStatus[i] = NULL;

   147         }

   148     }

   149 

   150 

   151 DLddUsbcChannel::~DLddUsbcChannel()

   152     {

   153     __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::~DLddUsbcChannel()"));

   154     if (iController)

   155         {

   156         iController->DeRegisterClient(this);

   157         iStatusCallbackInfo.Cancel();

   158         iEndpointStatusCallbackInfo.Cancel();

   159         iOtgFeatureCallbackInfo.Cancel();

   160         iCompleteAllCallbackInfo.Cancel();

   161         AbortInterface();

   162         DestroyAllInterfaces();

   163         if (iOwnsDeviceControl)

   164             {

   165             iController->ReleaseDeviceControl(this);

   166             iOwnsDeviceControl = EFalse;

   167             }

   168         DestroyEp0();

   169         delete iStatusFifo;

   170         Kern::DestroyClientRequest(iStatusChangeReq);

   171         Kern::DestroyClientRequest(iEndpointStatusChangeReq);

   172         Kern::DestroyClientRequest(iOtgFeatureChangeReq);

   173 

   174         Kern::DestroyVirtualPinObject(iPinObj1);

   175         Kern::DestroyVirtualPinObject(iPinObj2);

   176         Kern::DestroyVirtualPinObject(iPinObj3);

   177 

   178         for (TInt i = 0; i < KUsbcMaxRequests; i++)

   179             {

   180             Kern::DestroyClientBufferRequest(iClientAsynchNotify[i]->iBufferRequest);

   181             delete iClientAsynchNotify[i];

   182             }

   183         }

   184     Kern::SafeClose((DObject*&)iClient, NULL);

   185     }

   186 

   187 

   188 inline TBool DLddUsbcChannel::ValidEndpoint(TInt aEndpoint)

   189     {

   190     return (aEndpoint <= iNumberOfEndpoints && aEndpoint >= 0);

   191     }

   192 

   193 

   194 //

   195 // Create channel

   196 //

   197 TInt DLddUsbcChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer)

   198     {

   199     __KTRACE_OPT(KUSB, Kern::Printf("LDD DoCreateL 1 Ver = %02d %02d %02d",

   200                                     aVer.iMajor, aVer.iMinor, aVer.iBuild));

   201     if (!Kern::CurrentThreadHasCapability(ECapabilityCommDD,

   202                                           __PLATSEC_DIAGNOSTIC_STRING("Checked by USBC.LDD (USB Driver)")))

   203         {

   204         return KErrPermissionDenied;

   205         }

   206 

   207     iController = DUsbClientController::UsbcControllerPointer();

   208 

   209     if (!iController)

   210         {

   211         return KErrGeneral;

   212         }

   213 

   214     iStatusFifo = new TUsbcDeviceStatusQueue;

   215     if (iStatusFifo == NULL)

   216         {

   217         return KErrNoMemory;

   218         }

   219 

   220       if (!Kern::QueryVersionSupported(TVersion(KUsbcMajorVersion, KUsbcMinorVersion, KUsbcBuildVersion), aVer))

   221         {

   222         return KErrNotSupported;

   223         }

   224 

   225     // set up the correct DFC queue

   226     SetDfcQ(iController->DfcQ(0));                            // sets the channel's dfc queue

   227     #ifdef DFC_REALTIME_STATE

   228         iDfcQ.SetRealtimeState(ERealtimeStateOn);

   229     #endif

   230     iCompleteAllCallbackInfo.SetDfcQ(iDfcQ);

   231     iStatusCallbackInfo.SetDfcQ(iDfcQ);                        // use the channel's dfcq for this dfc

   232     iEndpointStatusCallbackInfo.SetDfcQ(iDfcQ);                // use the channel's dfcq for this dfc

   233     iOtgFeatureCallbackInfo.SetDfcQ(iDfcQ);

   234     iMsgQ.Receive();                                        //start up the message q

   235     TInt r = iController->RegisterClientCallback(iCompleteAllCallbackInfo);

   236     if (r != KErrNone)

   237         return r;

   238     r = iController->RegisterForStatusChange(iStatusCallbackInfo);

   239     if (r != KErrNone)

   240         return r;

   241     r = iController->RegisterForEndpointStatusChange(iEndpointStatusCallbackInfo);

   242     if (r != KErrNone)

   243         return r;

   244     r = iController->RegisterForOtgFeatureChange(iOtgFeatureCallbackInfo);

   245     if (r != KErrNone)

   246         return r;

   247 

   248     r = Kern::CreateClientDataRequest(iStatusChangeReq);

   249     if (r != KErrNone)

   250         return r;

   251     r = Kern::CreateClientDataRequest(iEndpointStatusChangeReq);

   252     if (r != KErrNone)

   253         return r;

   254     r = Kern::CreateClientDataRequest(iOtgFeatureChangeReq);

   255     if (r != KErrNone)

   256         return r;

   257     

   258     Kern::CreateVirtualPinObject(iPinObj1);

   259     Kern::CreateVirtualPinObject(iPinObj2);

   260     Kern::CreateVirtualPinObject(iPinObj3);

   261 

   262     for (TInt i = 0; i < KUsbcMaxRequests; i++)

   263         {

   264             iClientAsynchNotify[i] = new TClientAsynchNotify;

   265             if(iClientAsynchNotify[i] == NULL)

   266                 return KErrNoMemory;

   267             r = Kern::CreateClientBufferRequest(iClientAsynchNotify[i]->iBufferRequest,1,TClientBufferRequest::EPinVirtual);

   268             if (r != KErrNone)

   269                 {

   270                 delete iClientAsynchNotify[i];

   271                 iClientAsynchNotify[i]=NULL;

   272                 return r;

   273                 }

   274         }

   275     

   276     return r;

   277     }

   278 

   279 

   280 

   281 void DLddUsbcChannel::CompleteBufferRequest(DThread* aThread, TInt aReqNo, TInt aReason)

   282 {

   283     iRequestStatus[aReqNo]=NULL;

   284     Kern::QueueBufferRequestComplete(aThread, iClientAsynchNotify[aReqNo]->iBufferRequest, aReason);

   285 }

   286 

   287 

   288 TClientBuffer * DLddUsbcChannel::GetClientBuffer(TInt aEndpoint)

   289 {

   290     return iClientAsynchNotify[aEndpoint]->iClientBuffer;

   291 }

   292 

   293 //Runs in client thread

   294 TInt DLddUsbcChannel::SendMsg(TMessageBase * aMsg)

   295 {

   296     TThreadMessage& m=* (TThreadMessage*)aMsg;

   297     TInt id = m.iValue;

   298     

   299     TInt r = KErrNone;

   300     //Cancel Request

   301     if (id == KMaxTInt)

   302         {

   303             r = DLogicalChannel::SendMsg(aMsg);

   304             return r;

   305         }

   306     if (id < 0)

   307         {

   308         // DoRequest

   309         TRequestStatus* pS = (TRequestStatus*) m.Ptr0();

   310         r = PreSendRequest(aMsg,~id, pS, m.Ptr1(), m.Ptr2());

   311         if (r == KErrNone)

   312             {

   313             r = DLogicalChannel::SendMsg(aMsg);

   314             }

   315         }

   316     else

   317         {

   318         //SendControl

   319         r = SendControl(aMsg);

   320         }

   321     return r;

   322 }

   323 

   324 

   325 TInt DLddUsbcChannel::PreSendRequest(TMessageBase * aMsg,TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)

   326 {

   327     TInt r = KErrNone;

   328     if (aReqNo >= KUsbcMaxRequests)

   329     {

   330         Kern::RequestComplete(aStatus, KErrNotSupported);

   331         return KErrNotSupported;

   332     }

   333     if (aReqNo > KUsbcMaxEpNumber)//DoOtherAsyncReq

   334     {

   335         switch (aReqNo)

   336         {

   337             case RDevUsbcClient::ERequestEndpointStatusNotify:

   338                 iEndpointStatusChangeReq->Reset();

   339                 iEndpointStatusChangeReq->SetStatus(aStatus);

   340                 iEndpointStatusChangeReq->SetDestPtr(a1);

   341             break;

   342             case RDevUsbcClient::ERequestOtgFeaturesNotify:

   343                 iOtgFeatureChangeReq->Reset();

   344                 iOtgFeatureChangeReq->SetStatus(aStatus);

   345                 iOtgFeatureChangeReq->SetDestPtr(a1);

   346             break;

   347             case RDevUsbcClient::ERequestAlternateDeviceStatusNotify:

   348                 iStatusChangeReq->Reset();

   349                 iStatusChangeReq->SetStatus(aStatus);

   350                 iStatusChangeReq->SetDestPtr(a1);

   351             break;

   352             case RDevUsbcClient::ERequestReEnumerate://WE use bufferrequest to complete even tho we dont add any buffers

   353                 iClientAsynchNotify[aReqNo]->Reset();

   354                 r=iClientAsynchNotify[aReqNo]->iBufferRequest->StartSetup(aStatus);

   355                 if (r != KErrNone)

   356                     return r;

   357                 iClientAsynchNotify[aReqNo]->iBufferRequest->EndSetup();

   358             break;

   359         }

   360     }

   361     else //DoTransferAsyncReq

   362     {

   363             if(a1 == NULL)

   364                 return KErrArgument;

   365             iClientAsynchNotify[aReqNo]->Reset();

   366             r=iClientAsynchNotify[aReqNo]->iBufferRequest->StartSetup(aStatus);

   367             if (r != KErrNone)

   368                 return r;

   369             kumemget(&iTfrInfo,a1,sizeof(TEndpointTransferInfo));

   370             r=iClientAsynchNotify[aReqNo]->iBufferRequest->AddBuffer(iClientAsynchNotify[aReqNo]->iClientBuffer, iTfrInfo.iDes);

   371             if (r != KErrNone)

   372                 return r;

   373             iClientAsynchNotify[aReqNo]->iBufferRequest->EndSetup();

   374             TThreadMessage& m=*(TThreadMessage*)aMsg;

   375             m.iArg[1] = (TAny*)&iTfrInfo; //Use Channel owned TransfereInfo structure 

   376     }

   377     return KErrNone;

   378 }

   379 

   380 

   381 void DLddUsbcChannel::HandleMsg(TMessageBase* aMsg)

   382     {

   383     TThreadMessage& m = *(TThreadMessage*)aMsg;

   384     TInt id = m.iValue;

   385     if (id == (TInt) ECloseMsg)

   386         {

   387         iChannelClosing = ETrue;

   388         m.Complete(KErrNone, EFalse);

   389         return;

   390         }

   391     else if (id == KMaxTInt)

   392         {

   393         // Cancel request

   394         TInt mask = m.Int0();

   395         TInt b = 1;

   396         for(TInt reqNo = 0; reqNo < KUsbcMaxRequests; reqNo++)

   397             {

   398             TRequestStatus* pS = iRequestStatus[reqNo];

   399             if ((mask & b) && (pS != NULL))

   400                 {

   401                 DoCancel(reqNo);

   402                 }

   403             b <<= 1;

   404             }

   405         m.Complete(KErrNone, ETrue);

   406         return;

   407         }

   408 

   409     if (id < 0)

   410         {

   411         // DoRequest

   412         TRequestStatus* pS = (TRequestStatus*) m.Ptr0();

   413         DoRequest(~id, pS, m.Ptr1(), m.Ptr2());

   414         m.Complete(KErrNone, ETrue);

   415         }

   416     else

   417         {

   418         // DoControl

   419         TInt r = DoControl(id, m.Ptr0(), m.Ptr1());

   420         m.Complete(r, ETrue);

   421         }

   422     }

   423 

   424 

   425 //

   426 // Overriding DObject virtual

   427 //

   428 TInt DLddUsbcChannel::RequestUserHandle(DThread* aThread, TOwnerType /*aType*/)

   429     {

   430     __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::RequestUserHandle"));

   431     // The USB client LDD is not designed for a channel to be shared between

   432     // threads. It saves a pointer to the current thread when it is opened, and

   433     // uses this to complete any asynchronous requests.

   434     // It is therefore not acceptable for the handle to be duplicated and used

   435     // by another thread:

   436     if (aThread == iClient)

   437         {

   438         return KErrNone;

   439         }

   440     else

   441         {

   442         return KErrAccessDenied;

   443         }

   444     }

   445 

   446 

   447 //

   448 // Asynchronous requests - overriding pure virtual

   449 //

   450 void DLddUsbcChannel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)

   451     {

   452     // Check on request status

   453     __KTRACE_OPT(KUSB, Kern::Printf("DoRequest 0x%08x", aReqNo));

   454         TInt r = KErrNone;

   455         if (iRequestStatus[aReqNo] != NULL)

   456             {

   457             DestroyAllInterfaces();

   458             PanicClientThread(ERequestAlreadyPending);

   459             }

   460         else

   461             {

   462             TBool needsCompletion;

   463             iRequestStatus[aReqNo] = aStatus;

   464 

   465             if (aReqNo > KUsbcMaxEpNumber)

   466                 {

   467                 r = DoOtherAsyncReq(aReqNo, a1, a2, needsCompletion);

   468                 if (needsCompletion)

   469                     {

   470                     switch (aReqNo)

   471                     {

   472                         case RDevUsbcClient::ERequestEndpointStatusNotify:

   473                             iRequestStatus[aReqNo]=NULL;

   474                             Kern::QueueRequestComplete(iClient,iEndpointStatusChangeReq,r);

   475                         break;

   476                         case RDevUsbcClient::ERequestOtgFeaturesNotify:

   477                             iRequestStatus[aReqNo]=NULL;

   478                             Kern::QueueRequestComplete(iClient,iOtgFeatureChangeReq,r);

   479                         break;

   480                         case RDevUsbcClient::ERequestAlternateDeviceStatusNotify:

   481                             iRequestStatus[aReqNo]=NULL;

   482                             Kern::QueueRequestComplete(iClient,iStatusChangeReq,r);

   483                         break;

   484                         case RDevUsbcClient::ERequestReEnumerate:

   485                             iRequestStatus[aReqNo]=NULL;

   486                             Kern::QueueBufferRequestComplete(iClient, iClientAsynchNotify[aReqNo]->iBufferRequest, r);

   487                         break;

   488                     }

   489                   }

   490                 }

   491             else

   492                 {

   493                 r = DoTransferAsyncReq(aReqNo, a1, a2, needsCompletion);

   494                 if (needsCompletion)

   495                     {

   496                     //Kern::RequestComplete(iClient, iRequestStatus[aReqNo], r);

   497                     CompleteBufferRequest(iClient, aReqNo, r);

   498                     }

   499                 }

   500             }

   501     }

   502 

   503 

   504 

   505 TInt DLddUsbcChannel::DoOtherAsyncReq(TInt aReqNo, TAny* a1, TAny* a2, TBool& aNeedsCompletion)

   506     {

   507     // The general assumption is that none of these will complete now.

   508     // However, those that make this function return something other than

   509     // KErrNone will get completed by the calling function.

   510     // So, 1) If you are returning KErrNone but really need to complete because

   511     //        completion criteria can be met (for example, sufficient data is

   512     //        available in the buffer) and then set aNeedsCompletion = ETrue.

   513     //     2) Do NOT complete here AT ALL.

   514     //

   515     aNeedsCompletion = EFalse;

   516     TInt r = KErrNone;

   517 

   518     switch (aReqNo)

   519         {

   520     case RDevUsbcClient::ERequestAlternateDeviceStatusNotify:

   521         {

   522         __KTRACE_OPT(KUSB, Kern::Printf("EControlReqDeviceStatusNotify"));

   523         if (a1 != NULL)

   524             {

   525             iDeviceStatusNeeded = ETrue;

   526             iStatusChangePtr = a1;

   527             aNeedsCompletion = AlternateDeviceStateTestComplete();

   528             }

   529         else

   530             r = KErrArgument;

   531         break;

   532         }

   533     case RDevUsbcClient::ERequestReEnumerate:

   534         {

   535         __KTRACE_OPT(KUSB, Kern::Printf("ERequestReEnumerate"));

   536         // If successful, this will complete via the status notification.

   537         r = iController->ReEnumerate();

   538         break;

   539         }

   540     case RDevUsbcClient::ERequestEndpointStatusNotify:

   541         {

   542         __KTRACE_OPT(KUSB, Kern::Printf("ERequestEndpointStatusNotify"));

   543         if (a1 != NULL)

   544             {

   545             iEndpointStatusChangePtr = a1;

   546             }

   547         else

   548             r = KErrArgument;

   549         break;

   550             }

   551     case RDevUsbcClient::ERequestOtgFeaturesNotify:

   552         {

   553         __KTRACE_OPT(KUSB, Kern::Printf("ERequestOtgFeaturesNotify"));

   554         if (a1 != NULL)

   555             {

   556             iOtgFeatureChangePtr = a1;

   557             }

   558         else

   559             r = KErrArgument;

   560         break;

   561         }

   562     default:

   563         r = KErrNotSupported;

   564         }

   565 

   566     aNeedsCompletion = aNeedsCompletion || (r != KErrNone);

   567 

   568     return r;

   569     }

   570 

   571 

   572 TInt DLddUsbcChannel::DoTransferAsyncReq(TInt aEndpointNum, TAny* a1, TAny* a2, TBool& aNeedsCompletion)

   573     {

   574     // The general assumption is that none of these will complete now.

   575     // however, those that are returning something other than KErrNone will get completed

   576     // by the calling function.

   577     // So,    1) if you are returning KErrNone but really need to complete because completion criteria can be met

   578     //            (for example, sufficient data is available in the buffer) and then set aNeedsCompletion=ETrue..

   579     //        2) Do NOT complete here AT ALL.

   580     //

   581     aNeedsCompletion = EFalse;

   582     TInt r = KErrNone;

   583     TUsbcEndpoint* pEndpoint = NULL;

   584     TUsbcEndpointInfo* pEndpointInfo = NULL;

   585     TEndpointTransferInfo* pTfr = NULL;

   586 

   587     if (aEndpointNum == 0)

   588         {

   589         // ep0 requests

   590         if (!(iValidInterface || iOwnsDeviceControl))

   591             {

   592             __KTRACE_OPT(KUSB, Kern::Printf("DoRequest rejected: not configured (Ep0)"));

   593             r = KErrUsbInterfaceNotReady;

   594             goto exit;

   595             }

   596         }

   597     else

   598         {

   599         // other eps

   600         if (!(iValidInterface && (iDeviceState == UsbShai::EUsbPeripheralStateConfigured ||

   601                                   iDeviceState == UsbShai::EUsbPeripheralStateSuspended))

   602            )

   603             {

   604             __KTRACE_OPT(KUSB, Kern::Printf("DoRequest rejected not configured (Ep %d)", aEndpointNum));

   605             r = KErrUsbInterfaceNotReady;

   606             goto exit;

   607             }

   608         }

   609 

   610     if (!ValidEndpoint(aEndpointNum))

   611         {

   612         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: DoRequest Read: in error complete"));

   613         r = KErrUsbEpNotInInterface;

   614         goto exit;

   615          }

   616 

   617     if (a1 == NULL)

   618         {

   619         r = KErrArgument;

   620         goto exit;

   621         }

   622     pTfr = (TEndpointTransferInfo *)a1;

   623 

   624     if (pTfr->iTransferSize < 0)

   625         {

   626         r = KErrArgument;

   627         goto exit;

   628         }

   629     pEndpoint = iEndpoint[aEndpointNum];

   630     if (!pEndpoint)

   631         {

   632         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: DoRequest Read: in error complete"));

   633         r = KErrUsbEpNotInInterface;

   634         goto exit;

   635         }

   636 

   637     pEndpointInfo = pEndpoint->EndpointInfo();

   638     __KTRACE_OPT(KUSB, Kern::Printf("DoRequest %d", aEndpointNum));

   639 

   640     switch (pTfr->iTransferType)

   641         {

   642 

   643     case ETransferTypeReadData:

   644     case ETransferTypeReadPacket:

   645     case ETransferTypeReadUntilShort:

   646     case ETransferTypeReadOneOrMore:

   647         {

   648         __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read"));

   649         if (pEndpoint->iDmaBuffers->RxIsActive())

   650             {

   651             __KTRACE_OPT(KUSB, Kern::Printf("**** ReadReq ep%d RxActive", aEndpointNum));

   652             }

   653         else

   654             {

   655             __KTRACE_OPT(KUSB, Kern::Printf("**** ReadReq ep%d RxInActive", aEndpointNum));

   656             }

   657 

   658         if (pEndpointInfo->iDir != UsbShai::KUsbEpDirOut &&

   659             pEndpointInfo->iDir != UsbShai::KUsbEpDirBidirect)

   660             {

   661             // Trying to do the wrong thing

   662             __KTRACE_OPT(KPANIC, Kern::Printf("  Error: DoRequest Read: in error complete"));

   663             r = KErrUsbEpBadDirection;

   664             break;

   665             }

   666         // Set the length of data to zero now to catch all cases

   667         TPtrC8 pZeroDesc(NULL, 0);

   668         r=Kern::ThreadBufWrite(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer, pZeroDesc, 0, 0,iClient);

   669         if (r != KErrNone)

   670             PanicClientThread(r);

   671         pEndpoint->SetTransferInfo(pTfr);

   672         if (pEndpoint->iDmaBuffers->IsReaderEmpty())

   673             {

   674             pEndpoint->SetClientReadPending(ETrue);

   675             }

   676         else

   677             {

   678             if (pTfr->iTransferType == ETransferTypeReadPacket)

   679                 {

   680                 __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read packet: data available complete"));

   681                 r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer);

   682                 aNeedsCompletion = ETrue;

   683                 break;

   684                 }

   685             else if (pTfr->iTransferType == ETransferTypeReadData)

   686                 {

   687                 if (pTfr->iTransferSize <= pEndpoint->RxBytesAvailable())

   688                     {

   689                     __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read data: data available complete"));

   690                     r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer);

   691                     aNeedsCompletion = ETrue;

   692                     break;

   693                     }

   694                 else

   695                     {

   696                     pEndpoint->SetClientReadPending(ETrue);

   697                     }

   698                 }

   699             else if (pTfr->iTransferType == ETransferTypeReadOneOrMore)

   700                 {

   701                 if (pEndpoint->RxBytesAvailable() > 0)

   702                     {

   703                     __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read data: data available complete"));

   704                     r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer);

   705                     aNeedsCompletion = ETrue;

   706                     break;

   707                     }

   708                 else

   709                     {

   710                     pEndpoint->SetClientReadPending(ETrue);

   711                     }

   712                 }

   713             else if (pTfr->iTransferType == ETransferTypeReadUntilShort)

   714                 {

   715                 TInt nRx = pEndpoint->RxBytesAvailable();

   716                 TInt maxPacketSize = pEndpoint->EndpointInfo()->iSize;

   717                 if( (pTfr->iTransferSize <= nRx) ||

   718                     (nRx < maxPacketSize) ||

   719                     pEndpoint->iDmaBuffers->ShortPacketExists())

   720                     {

   721                     __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read data: data available complete"));

   722                     r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer);

   723                     aNeedsCompletion = ETrue;

   724                     }

   725                 else

   726                     {

   727                     pEndpoint->SetClientReadPending(ETrue);

   728                     }

   729                 }

   730             }

   731         r = pEndpoint->TryToStartRead(EFalse);

   732         if (r != KErrNone)

   733             {

   734             __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read: couldn't start read"));

   735             r = KErrNone;                                    // Reader full isn't a userside error;

   736             }

   737         break;

   738         }

   739 

   740     case ETransferTypeWrite:

   741         {

   742         __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Write 1"));

   743         if (pEndpointInfo->iDir != UsbShai::KUsbEpDirIn &&

   744             pEndpointInfo->iDir != UsbShai::KUsbEpDirBidirect)

   745             {

   746             __KTRACE_OPT(KPANIC, Kern::Printf("  Error: DoRequest Write: wrong direction complete"));

   747             r = KErrUsbEpBadDirection;

   748             break;

   749             }

   750         __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Write 2"));

   751 

   752 

   753         TInt desLength=iClientAsynchNotify[aEndpointNum]->iClientBuffer->Length();

   754         

   755         if (desLength < pTfr->iTransferSize)

   756             {

   757             __KTRACE_OPT(KPANIC, Kern::Printf("  Error: DoRequest Write: user buffer too short"));

   758             r = KErrUsbTransferSize;

   759             break;

   760             }

   761 

   762         __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Write 3 length=%d maxlength=%d",

   763                                         pTfr->iTransferSize, desLength));

   764         // Zero length writes are acceptable

   765         pEndpoint->SetClientWritePending(ETrue);

   766         r = pEndpoint->TryToStartWrite(pTfr);

   767         if (r != KErrNone)

   768             {

   769             __KTRACE_OPT(KPANIC, Kern::Printf("  Error: DoRequest Write: couldn't start write"));

   770             pEndpoint->SetClientWritePending(EFalse);

   771             }

   772         break;

   773         }

   774 

   775     default:

   776         __KTRACE_OPT(KPANIC, Kern::Printf("  Error: DoTransferAsyncReq: pTfr->iTransferType = %d not supported",

   777                                           pTfr->iTransferType));

   778         r = KErrNotSupported;

   779         break;

   780         }

   781  exit:

   782     aNeedsCompletion = aNeedsCompletion || (r != KErrNone);

   783     return r;

   784     }

   785 

   786 

   787 //

   788 // Cancel an outstanding request - overriding pure virtual

   789 //

   790 TInt DLddUsbcChannel::DoCancel(TInt aReqNo)

   791     {

   792     TInt r = KErrNone;

   793     __KTRACE_OPT(KUSB, Kern::Printf("DoCancel: 0x%x", aReqNo));

   794     if (aReqNo <= iNumberOfEndpoints)

   795         {

   796         __KTRACE_OPT(KUSB, Kern::Printf("DoCancel endpoint: 0x%x", aReqNo));

   797         iEndpoint[aReqNo]->CancelTransfer(iClient,iClientAsynchNotify[aReqNo]->iClientBuffer);

   798         }

   799     else if (aReqNo == RDevUsbcClient::ERequestAlternateDeviceStatusNotify)

   800         {

   801         __KTRACE_OPT(KUSB, Kern::Printf("DoCancel: ERequestAlternateDeviceStatusNotify 0x%x", aReqNo));

   802         iDeviceStatusNeeded = EFalse;

   803         iStatusFifo->FlushQueue();

   804         if (iStatusChangePtr)

   805             {

   806             iStatusChangeReq->Data()=iController->GetDeviceStatus();

   807             iStatusChangePtr = NULL;

   808 

   809             if (iStatusChangeReq->IsReady())

   810                 {

   811                 iRequestStatus[aReqNo] = NULL;

   812                 Kern::QueueRequestComplete(iClient, iStatusChangeReq, KErrCancel);

   813                 }

   814                 return KErrNone;

   815             }

   816         }

   817     else if (aReqNo == RDevUsbcClient::ERequestReEnumerate)

   818         {

   819         __KTRACE_OPT(KUSB, Kern::Printf("DoCancel ERequestReEnumerate: 0x%x", aReqNo));

   820         }

   821     else if (aReqNo == RDevUsbcClient::ERequestEndpointStatusNotify)

   822         {

   823         __KTRACE_OPT(KUSB, Kern::Printf("DoCancel ERequestEndpointStatusNotify: 0x%x", aReqNo));

   824         CancelNotifyEndpointStatus();

   825         if (iEndpointStatusChangeReq->IsReady())

   826             {

   827             iRequestStatus[aReqNo] = NULL;

   828             Kern::QueueRequestComplete(iClient, iEndpointStatusChangeReq, KErrCancel);

   829             }

   830         return KErrNone;

   831         }

   832     else if (aReqNo == RDevUsbcClient::ERequestOtgFeaturesNotify)

   833         {

   834         __KTRACE_OPT(KUSB, Kern::Printf("DoCancel ERequestOtgFeaturesNotify: 0x%x", aReqNo));

   835         CancelNotifyOtgFeatures();

   836         if (iOtgFeatureChangeReq->IsReady())

   837             {

   838             iRequestStatus[aReqNo] = NULL;

   839             Kern::QueueRequestComplete(iClient, iOtgFeatureChangeReq, KErrCancel);

   840             }

   841         }

   842     else

   843         {

   844         __KTRACE_OPT(KUSB, Kern::Printf("DoCancel Unknown! 0x%x", aReqNo));

   845         }

   846 

   847         if (r == KErrNone)

   848             r = KErrCancel;

   849 

   850         CompleteBufferRequest(iClient, aReqNo, r);

   851     return r;

   852     }

   853 

   854 

   855 void DLddUsbcChannel::CancelNotifyEndpointStatus()

   856     {

   857     if (iEndpointStatusChangePtr)

   858         {

   859         TUint epBitmap = 0;

   860         for (TInt i = 0; i <= iNumberOfEndpoints; i++)

   861             {

   862             TInt v = iController->GetEndpointStatus(this, iEndpoint[i]->RealEpNumber());

   863             TUint b;

   864             (v == EEndpointStateStalled) ? b = 1 : b = 0;

   865             epBitmap |= b << i;

   866             }

   867         iEndpointStatusChangeReq->Data()=epBitmap;

   868         iEndpointStatusChangePtr = NULL;

   869         }

   870     }

   871 

   872 

   873 void DLddUsbcChannel::CancelNotifyOtgFeatures()

   874     {

   875     if (iOtgFeatureChangePtr)

   876         {

   877         TUint8 features;

   878         iController->GetCurrentOtgFeatures(features);

   879      iOtgFeatureChangeReq->Data()=features;

   880         iOtgFeatureChangePtr = NULL;

   881         }

   882     }

   883 

   884 TInt DLddUsbcChannel::PinMemory(TDesC8 *aDes, TVirtualPinObject *aPinObj)

   885     {

   886     TInt r = KErrNone;

   887     TInt  len,mlen;

   888     

   889     const TUint8*p = Kern::KUDesInfo(*aDes, len,mlen);

   890     r=Kern::PinVirtualMemory(aPinObj, (TLinAddr) p, len);

   891     return r;

   892     }

   893 

   894 //Called in Client thread context

   895 TInt DLddUsbcChannel::SendControl(TMessageBase* aMsg)

   896     {

   897     TThreadMessage& m=*(TThreadMessage*)aMsg;

   898     const TInt fn=m.iValue;

   899     TAny *const a1=m.Ptr0();

   900     TAny *const a2=m.Ptr1();

   901     TInt  kern_param;

   902     TEndpointDescriptorInfo epi;

   903     TUsbcIfcInfo ifc;

   904     TCSDescriptorInfo desInfo;

   905     TInt r = KErrNone;

   906 

   907     switch (fn)

   908         {

   909         

   910     case RDevUsbcClient::EControlDeviceStatus:

   911     case RDevUsbcClient::EControlGetAlternateSetting:

   912         m.iArg[0] = &kern_param;              // update message to point to kernel-side buffer

   913         break;

   914 

   915     case RDevUsbcClient::EControlQueryReceiveBuffer:

   916     case RDevUsbcClient::EControlEndpointStatus:

   917         m.iArg[1] = &kern_param;              // update message to point to kernel-side buffer

   918         break;

   919 

   920     case RDevUsbcClient::EControlEndpointCaps:

   921     case RDevUsbcClient::EControlDeviceCaps:

   922     case RDevUsbcClient::EControlGetDeviceDescriptor:

   923     case RDevUsbcClient::EControlSetDeviceDescriptor:

   924     case RDevUsbcClient::EControlGetDeviceDescriptorSize:

   925     case RDevUsbcClient::EControlGetConfigurationDescriptor:

   926     case RDevUsbcClient::EControlGetConfigurationDescriptorSize:

   927     case RDevUsbcClient::EControlGetDeviceQualifierDescriptor:

   928     case RDevUsbcClient::EControlSetDeviceQualifierDescriptor:

   929     case RDevUsbcClient::EControlGetOtherSpeedConfigurationDescriptor:

   930     case RDevUsbcClient::EControlSetOtherSpeedConfigurationDescriptor:

   931     case RDevUsbcClient::EControlGetStringDescriptorLangId:

   932     case RDevUsbcClient::EControlGetManufacturerStringDescriptor:

   933     case RDevUsbcClient::EControlSetManufacturerStringDescriptor:

   934     case RDevUsbcClient::EControlGetProductStringDescriptor:

   935     case RDevUsbcClient::EControlSetProductStringDescriptor:

   936     case RDevUsbcClient::EControlGetSerialNumberStringDescriptor:    

   937     case RDevUsbcClient::EControlSetSerialNumberStringDescriptor:

   938     case RDevUsbcClient::EControlGetConfigurationStringDescriptor:

   939     case RDevUsbcClient::EControlSetConfigurationStringDescriptor:

   940     case RDevUsbcClient::EControlSetOtgDescriptor:

   941     case RDevUsbcClient::EControlGetOtgDescriptor:

   942     case RDevUsbcClient::EControlGetOtgFeatures:

   943         r=PinMemory((TDesC8 *) a1, iPinObj1);

   944         if(r!=KErrNone)

   945             {

   946             PanicClientThread(r);

   947             return r;

   948             }

   949         break;

   950 

   951     case RDevUsbcClient::EControlGetInterfaceDescriptor:

   952     case RDevUsbcClient::EControlGetInterfaceDescriptorSize:

   953     case RDevUsbcClient::EControlSetInterfaceDescriptor:

   954     case RDevUsbcClient::EControlGetCSInterfaceDescriptor:

   955     case RDevUsbcClient::EControlGetCSInterfaceDescriptorSize:

   956     case RDevUsbcClient::EControlGetStringDescriptor:

   957     case RDevUsbcClient::EControlSetStringDescriptor:

   958         r=PinMemory((TDesC8 *) a2, iPinObj1);

   959         if(r!=KErrNone)

   960             {

   961             PanicClientThread(r);

   962             return r;

   963             }

   964         break;

   965 

   966     case RDevUsbcClient::EControlGetEndpointDescriptor:

   967     case RDevUsbcClient::EControlGetEndpointDescriptorSize:

   968     case RDevUsbcClient::EControlSetEndpointDescriptor:

   969     case RDevUsbcClient::EControlGetCSEndpointDescriptor:

   970     case RDevUsbcClient::EControlGetCSEndpointDescriptorSize:

   971         if(a1!=NULL)

   972             {

   973             r=Kern::PinVirtualMemory(iPinObj1, (TLinAddr)a1, sizeof(epi));

   974             if(r!=KErrNone)

   975                 {

   976                 PanicClientThread(r);

   977                 return r;

   978                 }

   979             kumemget(&epi, a1, sizeof(epi));

   980             r=PinMemory((TDesC8 *) epi.iArg, iPinObj2);

   981             if(r!=KErrNone)

   982                 {

   983                 Kern::UnpinVirtualMemory(iPinObj1);

   984                 PanicClientThread(r);

   985                 return r;

   986                 }

   987             }

   988         break;

   989 

   990     case RDevUsbcClient::EControlSetInterface:

   991         if(a2!=NULL)

   992             {

   993             r=Kern::PinVirtualMemory(iPinObj1, (TLinAddr)a2, sizeof(ifc));

   994             if(r!=KErrNone)

   995                 {

   996                 PanicClientThread(r);

   997                 return r;

   998                 }    

   999             kumemget(&ifc, a2, sizeof(ifc));                

  1000             r=PinMemory((TDesC8 *) ifc.iInterfaceData, iPinObj2);

  1001             if(r!=KErrNone)

  1002                 {

  1003                 Kern::UnpinVirtualMemory(iPinObj1);

  1004                 PanicClientThread(r);

  1005                 return r;

  1006                 }

  1007             }

  1008         break;

  1009 

  1010     case RDevUsbcClient::EControlSetCSInterfaceDescriptor:

  1011     case RDevUsbcClient::EControlSetCSEndpointDescriptor:

  1012         if(a1!=NULL)

  1013             {

  1014             r=Kern::PinVirtualMemory(iPinObj1, (TLinAddr)a1, sizeof(desInfo));

  1015             if(r!=KErrNone)

  1016                 {

  1017                 PanicClientThread(r);

  1018                 return r;

  1019                 }

  1020             kumemget(&desInfo, a1, sizeof(desInfo));

  1021             r=PinMemory((TDesC8 *) desInfo.iArg, iPinObj2);

  1022             if(r!=KErrNone)

  1023                 {

  1024                 Kern::UnpinVirtualMemory(iPinObj1);

  1025                 PanicClientThread(r);

  1026                 return r;

  1027                 }

  1028             }

  1029         break;

  1030     }

  1031 

  1032 

  1033     //Send Message and wait for synchronous complete    

  1034     r = DLogicalChannel::SendMsg(aMsg);

  1035     

  1036     

  1037     

  1038     switch (fn)

  1039         {

  1040     case RDevUsbcClient::EControlDeviceStatus:

  1041     case RDevUsbcClient::EControlGetAlternateSetting:

  1042         umemput32(a1, &kern_param, sizeof(kern_param));

  1043         break;

  1044 

  1045     case RDevUsbcClient::EControlQueryReceiveBuffer:

  1046     case RDevUsbcClient::EControlEndpointStatus:

  1047         umemput32(a2, &kern_param, sizeof(kern_param));

  1048         break;

  1049 

  1050     case RDevUsbcClient::EControlDeviceCaps:

  1051     case RDevUsbcClient::EControlEndpointCaps:

  1052     case RDevUsbcClient::EControlGetDeviceDescriptor:

  1053     case RDevUsbcClient::EControlSetDeviceDescriptor:

  1054     case RDevUsbcClient::EControlGetDeviceDescriptorSize:

  1055     case RDevUsbcClient::EControlGetConfigurationDescriptor:

  1056     case RDevUsbcClient::EControlGetConfigurationDescriptorSize:

  1057     case RDevUsbcClient::EControlGetDeviceQualifierDescriptor:

  1058     case RDevUsbcClient::EControlSetDeviceQualifierDescriptor:

  1059     case RDevUsbcClient::EControlGetOtherSpeedConfigurationDescriptor:

  1060     case RDevUsbcClient::EControlSetOtherSpeedConfigurationDescriptor:

  1061     case RDevUsbcClient::EControlGetStringDescriptorLangId:

  1062     case RDevUsbcClient::EControlGetManufacturerStringDescriptor:

  1063     case RDevUsbcClient::EControlSetManufacturerStringDescriptor:

  1064     case RDevUsbcClient::EControlGetProductStringDescriptor:

  1065     case RDevUsbcClient::EControlSetProductStringDescriptor:

  1066     case RDevUsbcClient::EControlGetSerialNumberStringDescriptor:    

  1067     case RDevUsbcClient::EControlSetSerialNumberStringDescriptor:

  1068     case RDevUsbcClient::EControlGetConfigurationStringDescriptor:

  1069     case RDevUsbcClient::EControlSetConfigurationStringDescriptor:

  1070     case RDevUsbcClient::EControlSetOtgDescriptor:

  1071     case RDevUsbcClient::EControlGetOtgDescriptor:

  1072     case RDevUsbcClient::EControlGetOtgFeatures:

  1073         if(a1!=NULL)

  1074             {

  1075             Kern::UnpinVirtualMemory(iPinObj1);

  1076             }

  1077         break;

  1078 

  1079     case RDevUsbcClient::EControlGetInterfaceDescriptor:

  1080     case RDevUsbcClient::EControlGetInterfaceDescriptorSize:

  1081     case RDevUsbcClient::EControlSetInterfaceDescriptor:

  1082     case RDevUsbcClient::EControlGetCSInterfaceDescriptor:

  1083     case RDevUsbcClient::EControlGetCSInterfaceDescriptorSize:

  1084     case RDevUsbcClient::EControlGetStringDescriptor:

  1085     case RDevUsbcClient::EControlSetStringDescriptor:

  1086         if(a2!=NULL)

  1087             {

  1088             Kern::UnpinVirtualMemory(iPinObj1);

  1089             }

  1090         break;

  1091     

  1092     case RDevUsbcClient::EControlGetEndpointDescriptor:

  1093     case RDevUsbcClient::EControlGetEndpointDescriptorSize:

  1094     case RDevUsbcClient::EControlSetEndpointDescriptor:

  1095     case RDevUsbcClient::EControlGetCSEndpointDescriptor:

  1096     case RDevUsbcClient::EControlGetCSEndpointDescriptorSize:

  1097     case RDevUsbcClient::EControlSetCSInterfaceDescriptor:

  1098     case RDevUsbcClient::EControlSetCSEndpointDescriptor:

  1099         if(a1!=NULL)

  1100             {

  1101             Kern::UnpinVirtualMemory(iPinObj1);

  1102             Kern::UnpinVirtualMemory(iPinObj2);

  1103             }

  1104         break;

  1105 

  1106     case RDevUsbcClient::EControlSetInterface:

  1107         if(a2!=NULL)

  1108             {

  1109             Kern::UnpinVirtualMemory(iPinObj1);

  1110             Kern::UnpinVirtualMemory(iPinObj2);

  1111             }

  1112         break;

  1113         }

  1114 

  1115     return r;

  1116     }

  1117 

  1118 

  1119 TInt DLddUsbcChannel::DoControl(TInt aFunction, TAny* a1, TAny* a2)

  1120     {

  1121     __KTRACE_OPT(KUSB, Kern::Printf("DoControl: %d", aFunction));

  1122 

  1123     TInt r = KErrNone;

  1124     TInt ep;

  1125     TUsbcEndpoint* pEndpoint;

  1126     TPtrC8 pZeroDesc(NULL, 0);

  1127     TEndpointDescriptorInfo epInfo;

  1128     TUsbcIfcInfo ifcInfo;

  1129     TCSDescriptorInfo desInfo;

  1130     TUsbcEndpointResource epRes;

  1131     TInt bandwidthPriority;

  1132 

  1133     switch (aFunction)

  1134         {