--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/usbdrv/peripheral/ldd/perildd/src/d_usbc.cpp Fri Jul 23 15:54:47 2010 +0800
@@ -0,0 +1,3233 @@
+// Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// e32/drivers/usbc/d_usbc.cpp
+// LDD for USB Device driver stack:
+// The channel object.
+//
+//
+
+/**
+ @file d_usbc.cpp
+ @internalTechnology
+*/
+
+#include <usb/usbc.h>
+
+
+_LIT(KUsbLddName, "Usbc");
+
+static const TInt KUsbRequestCallbackPriority = 2;
+
+
+// Quick sanity check on endpoint properties
+static TBool ValidateEndpoint(const TUsbcEndpointInfo* aEndpointInfo)
+ {
+ const TUint dir = aEndpointInfo->iDir;
+ const TInt size = aEndpointInfo->iSize;
+ if (size <= 0)
+ return EFalse;
+
+ switch (aEndpointInfo->iType)
+ {
+ case UsbShai::KUsbEpTypeControl:
+ if (dir != UsbShai::KUsbEpDirBidirect || size > 64)
+ return EFalse;
+ break;
+ case UsbShai::KUsbEpTypeIsochronous:
+ if ((dir != UsbShai::KUsbEpDirIn && dir != UsbShai::KUsbEpDirOut) || size > 1024)
+ return EFalse;
+ break;
+ case UsbShai::KUsbEpTypeBulk:
+ if ((dir != UsbShai::KUsbEpDirIn && dir != UsbShai::KUsbEpDirOut) || size > 512)
+ return EFalse;
+ break;
+ case UsbShai::KUsbEpTypeInterrupt:
+ if ((dir != UsbShai::KUsbEpDirIn && dir != UsbShai::KUsbEpDirOut) || size > 1024)
+ return EFalse;
+ break;
+ default:
+ return EFalse;
+ }
+ return ETrue;
+ }
+
+
+/** Real entry point from the Kernel: return a new driver.
+ */
+DECLARE_STANDARD_LDD()
+ {
+ return new DUsbcLogDevice;
+ }
+
+
+/** Create a channel on the device.
+
+ @internalComponent
+*/
+TInt DUsbcLogDevice::Create(DLogicalChannelBase*& aChannel)
+ {
+ aChannel = new DLddUsbcChannel;
+ return aChannel ? KErrNone : KErrNoMemory;
+ }
+
+
+DUsbcLogDevice::DUsbcLogDevice()
+ {
+ iParseMask = KDeviceAllowUnit;
+ iUnitsMask = 0xffffffff; // Leave units decision to the Controller
+ iVersion = TVersion(KUsbcMajorVersion, KUsbcMinorVersion, KUsbcBuildVersion);
+ }
+
+
+TInt DUsbcLogDevice::Install()
+ {
+ // Only proceed if we have the Controller underneath us
+ if (!DUsbClientController::UsbcControllerPointer())
+ {
+ __KTRACE_OPT(KPANIC, Kern::Printf("LDD Install: USB Controller Not Present"));
+ return KErrGeneral;
+ }
+ return SetName(&KUsbLddName);
+ }
+
+
+//
+// Return the USB controller capabilities.
+//
+void DUsbcLogDevice::GetCaps(TDes8& aDes) const
+ {
+ TPckgBuf<TCapsDevUsbc> b;
+ b().version = iVersion;
+ Kern::InfoCopy(aDes, b);
+ }
+
+
+//
+// Constructor
+//
+DLddUsbcChannel::DLddUsbcChannel()
+ : iValidInterface(EFalse),
+ iAlternateSettingList(NULL),
+ iCompleteAllCallbackInfo(this, DLddUsbcChannel::EmergencyCompleteDfc, KUsbRequestCallbackPriority),
+ iStatusChangePtr(NULL),
+ iStatusCallbackInfo(this, DLddUsbcChannel::StatusChangeCallback, KUsbRequestCallbackPriority),
+ iEndpointStatusChangePtr(NULL),
+ iEndpointStatusCallbackInfo(this, DLddUsbcChannel::EndpointStatusChangeCallback,
+ KUsbRequestCallbackPriority),
+ iOtgFeatureChangePtr(NULL),
+ iOtgFeatureCallbackInfo(this, DLddUsbcChannel::OtgFeatureChangeCallback, KUsbRequestCallbackPriority),
+ iNumberOfEndpoints(0),
+ iDeviceState(UsbShai::EUsbPeripheralStateUndefined),
+ iOwnsDeviceControl(EFalse),
+ iAlternateSetting(0),
+ iDeviceStatusNeeded(EFalse),
+ iChannelClosing(EFalse)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("*** DLddUsbcChannel::DLddUsbcChannel CTOR"));
+ iClient = &Kern::CurrentThread();
+ iClient->Open();
+ for (TInt i = 1; i <= KMaxEndpointsPerClient; i++)
+ {
+ iEndpoint[i] = NULL;
+ }
+ for (TInt i = 1; i < KUsbcMaxRequests; i++)
+ {
+ iRequestStatus[i] = NULL;
+ }
+ }
+
+
+DLddUsbcChannel::~DLddUsbcChannel()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::~DLddUsbcChannel()"));
+ if (iController)
+ {
+ iController->DeRegisterClient(this);
+ iStatusCallbackInfo.Cancel();
+ iEndpointStatusCallbackInfo.Cancel();
+ iOtgFeatureCallbackInfo.Cancel();
+ iCompleteAllCallbackInfo.Cancel();
+ AbortInterface();
+ DestroyAllInterfaces();
+ if (iOwnsDeviceControl)
+ {
+ iController->ReleaseDeviceControl(this);
+ iOwnsDeviceControl = EFalse;
+ }
+ DestroyEp0();
+ delete iStatusFifo;
+ Kern::DestroyClientRequest(iStatusChangeReq);
+ Kern::DestroyClientRequest(iEndpointStatusChangeReq);
+ Kern::DestroyClientRequest(iOtgFeatureChangeReq);
+
+ Kern::DestroyVirtualPinObject(iPinObj1);
+ Kern::DestroyVirtualPinObject(iPinObj2);
+ Kern::DestroyVirtualPinObject(iPinObj3);
+
+ for (TInt i = 0; i < KUsbcMaxRequests; i++)
+ {
+ Kern::DestroyClientBufferRequest(iClientAsynchNotify[i]->iBufferRequest);
+ delete iClientAsynchNotify[i];
+ }
+ }
+ Kern::SafeClose((DObject*&)iClient, NULL);
+ }
+
+
+inline TBool DLddUsbcChannel::ValidEndpoint(TInt aEndpoint)
+ {
+ return (aEndpoint <= iNumberOfEndpoints && aEndpoint >= 0);
+ }
+
+
+//
+// Create channel
+//
+TInt DLddUsbcChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("LDD DoCreateL 1 Ver = %02d %02d %02d",
+ aVer.iMajor, aVer.iMinor, aVer.iBuild));
+ if (!Kern::CurrentThreadHasCapability(ECapabilityCommDD,
+ __PLATSEC_DIAGNOSTIC_STRING("Checked by USBC.LDD (USB Driver)")))
+ {
+ return KErrPermissionDenied;
+ }
+
+ iController = DUsbClientController::UsbcControllerPointer();
+
+ if (!iController)
+ {
+ return KErrGeneral;
+ }
+
+ iStatusFifo = new TUsbcDeviceStatusQueue;
+ if (iStatusFifo == NULL)
+ {
+ return KErrNoMemory;
+ }
+
+ if (!Kern::QueryVersionSupported(TVersion(KUsbcMajorVersion, KUsbcMinorVersion, KUsbcBuildVersion), aVer))
+ {
+ return KErrNotSupported;
+ }
+
+ // set up the correct DFC queue
+ SetDfcQ(iController->DfcQ(0)); // sets the channel's dfc queue
+ #ifdef DFC_REALTIME_STATE
+ iDfcQ.SetRealtimeState(ERealtimeStateOn);
+ #endif
+ iCompleteAllCallbackInfo.SetDfcQ(iDfcQ);
+ iStatusCallbackInfo.SetDfcQ(iDfcQ); // use the channel's dfcq for this dfc
+ iEndpointStatusCallbackInfo.SetDfcQ(iDfcQ); // use the channel's dfcq for this dfc
+ iOtgFeatureCallbackInfo.SetDfcQ(iDfcQ);
+ iMsgQ.Receive(); //start up the message q
+ TInt r = iController->RegisterClientCallback(iCompleteAllCallbackInfo);
+ if (r != KErrNone)
+ return r;
+ r = iController->RegisterForStatusChange(iStatusCallbackInfo);
+ if (r != KErrNone)
+ return r;
+ r = iController->RegisterForEndpointStatusChange(iEndpointStatusCallbackInfo);
+ if (r != KErrNone)
+ return r;
+ r = iController->RegisterForOtgFeatureChange(iOtgFeatureCallbackInfo);
+ if (r != KErrNone)
+ return r;
+
+ r = Kern::CreateClientDataRequest(iStatusChangeReq);
+ if (r != KErrNone)
+ return r;
+ r = Kern::CreateClientDataRequest(iEndpointStatusChangeReq);
+ if (r != KErrNone)
+ return r;
+ r = Kern::CreateClientDataRequest(iOtgFeatureChangeReq);
+ if (r != KErrNone)
+ return r;
+
+ Kern::CreateVirtualPinObject(iPinObj1);
+ Kern::CreateVirtualPinObject(iPinObj2);
+ Kern::CreateVirtualPinObject(iPinObj3);
+
+ for (TInt i = 0; i < KUsbcMaxRequests; i++)
+ {
+ iClientAsynchNotify[i] = new TClientAsynchNotify;
+ if(iClientAsynchNotify[i] == NULL)
+ return KErrNoMemory;
+ r = Kern::CreateClientBufferRequest(iClientAsynchNotify[i]->iBufferRequest,1,TClientBufferRequest::EPinVirtual);
+ if (r != KErrNone)
+ {
+ delete iClientAsynchNotify[i];
+ iClientAsynchNotify[i]=NULL;
+ return r;
+ }
+ }
+
+ return r;
+ }
+
+
+
+void DLddUsbcChannel::CompleteBufferRequest(DThread* aThread, TInt aReqNo, TInt aReason)
+{
+ iRequestStatus[aReqNo]=NULL;
+ Kern::QueueBufferRequestComplete(aThread, iClientAsynchNotify[aReqNo]->iBufferRequest, aReason);
+}
+
+
+TClientBuffer * DLddUsbcChannel::GetClientBuffer(TInt aEndpoint)
+{
+ return iClientAsynchNotify[aEndpoint]->iClientBuffer;
+}
+
+//Runs in client thread
+TInt DLddUsbcChannel::SendMsg(TMessageBase * aMsg)
+{
+ TThreadMessage& m=* (TThreadMessage*)aMsg;
+ TInt id = m.iValue;
+
+ TInt r = KErrNone;
+ //Cancel Request
+ if (id == KMaxTInt)
+ {
+ r = DLogicalChannel::SendMsg(aMsg);
+ return r;
+ }
+ if (id < 0)
+ {
+ // DoRequest
+ TRequestStatus* pS = (TRequestStatus*) m.Ptr0();
+ r = PreSendRequest(aMsg,~id, pS, m.Ptr1(), m.Ptr2());
+ if (r == KErrNone)
+ {
+ r = DLogicalChannel::SendMsg(aMsg);
+ }
+ }
+ else
+ {
+ //SendControl
+ r = SendControl(aMsg);
+ }
+ return r;
+}
+
+
+TInt DLddUsbcChannel::PreSendRequest(TMessageBase * aMsg,TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)
+{
+ TInt r = KErrNone;
+ if (aReqNo >= KUsbcMaxRequests)
+ {
+ Kern::RequestComplete(aStatus, KErrNotSupported);
+ return KErrNotSupported;
+ }
+ if (aReqNo > KUsbcMaxEpNumber)//DoOtherAsyncReq
+ {
+ switch (aReqNo)
+ {
+ case RDevUsbcClient::ERequestEndpointStatusNotify:
+ iEndpointStatusChangeReq->Reset();
+ iEndpointStatusChangeReq->SetStatus(aStatus);
+ iEndpointStatusChangeReq->SetDestPtr(a1);
+ break;
+ case RDevUsbcClient::ERequestOtgFeaturesNotify:
+ iOtgFeatureChangeReq->Reset();
+ iOtgFeatureChangeReq->SetStatus(aStatus);
+ iOtgFeatureChangeReq->SetDestPtr(a1);
+ break;
+ case RDevUsbcClient::ERequestAlternateDeviceStatusNotify:
+ iStatusChangeReq->Reset();
+ iStatusChangeReq->SetStatus(aStatus);
+ iStatusChangeReq->SetDestPtr(a1);
+ break;
+ case RDevUsbcClient::ERequestReEnumerate://WE use bufferrequest to complete even tho we dont add any buffers
+ iClientAsynchNotify[aReqNo]->Reset();
+ r=iClientAsynchNotify[aReqNo]->iBufferRequest->StartSetup(aStatus);
+ if (r != KErrNone)
+ return r;
+ iClientAsynchNotify[aReqNo]->iBufferRequest->EndSetup();
+ break;
+ }
+ }
+ else //DoTransferAsyncReq
+ {
+ if(a1 == NULL)
+ return KErrArgument;
+ iClientAsynchNotify[aReqNo]->Reset();
+ r=iClientAsynchNotify[aReqNo]->iBufferRequest->StartSetup(aStatus);
+ if (r != KErrNone)
+ return r;
+ kumemget(&iTfrInfo,a1,sizeof(TEndpointTransferInfo));
+ r=iClientAsynchNotify[aReqNo]->iBufferRequest->AddBuffer(iClientAsynchNotify[aReqNo]->iClientBuffer, iTfrInfo.iDes);
+ if (r != KErrNone)
+ return r;
+ iClientAsynchNotify[aReqNo]->iBufferRequest->EndSetup();
+ TThreadMessage& m=*(TThreadMessage*)aMsg;
+ m.iArg[1] = (TAny*)&iTfrInfo; //Use Channel owned TransfereInfo structure
+ }
+ return KErrNone;
+}
+
+
+void DLddUsbcChannel::HandleMsg(TMessageBase* aMsg)
+ {
+ TThreadMessage& m = *(TThreadMessage*)aMsg;
+ TInt id = m.iValue;
+ if (id == (TInt) ECloseMsg)
+ {
+ iChannelClosing = ETrue;
+ m.Complete(KErrNone, EFalse);
+ return;
+ }
+ else if (id == KMaxTInt)
+ {
+ // Cancel request
+ TInt mask = m.Int0();
+ TInt b = 1;
+ for(TInt reqNo = 0; reqNo < KUsbcMaxRequests; reqNo++)
+ {
+ TRequestStatus* pS = iRequestStatus[reqNo];
+ if ((mask & b) && (pS != NULL))
+ {
+ DoCancel(reqNo);
+ }
+ b <<= 1;
+ }
+ m.Complete(KErrNone, ETrue);
+ return;
+ }
+
+ if (id < 0)
+ {
+ // DoRequest
+ TRequestStatus* pS = (TRequestStatus*) m.Ptr0();
+ DoRequest(~id, pS, m.Ptr1(), m.Ptr2());
+ m.Complete(KErrNone, ETrue);
+ }
+ else
+ {
+ // DoControl
+ TInt r = DoControl(id, m.Ptr0(), m.Ptr1());
+ m.Complete(r, ETrue);
+ }
+ }
+
+
+//
+// Overriding DObject virtual
+//
+TInt DLddUsbcChannel::RequestUserHandle(DThread* aThread, TOwnerType /*aType*/)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::RequestUserHandle"));
+ // The USB client LDD is not designed for a channel to be shared between
+ // threads. It saves a pointer to the current thread when it is opened, and
+ // uses this to complete any asynchronous requests.
+ // It is therefore not acceptable for the handle to be duplicated and used
+ // by another thread:
+ if (aThread == iClient)
+ {
+ return KErrNone;
+ }
+ else
+ {
+ return KErrAccessDenied;
+ }
+ }
+
+
+//
+// Asynchronous requests - overriding pure virtual
+//
+void DLddUsbcChannel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)
+ {
+ // Check on request status
+ __KTRACE_OPT(KUSB, Kern::Printf("DoRequest 0x%08x", aReqNo));
+ TInt r = KErrNone;
+ if (iRequestStatus[aReqNo] != NULL)
+ {
+ DestroyAllInterfaces();
+ PanicClientThread(ERequestAlreadyPending);
+ }
+ else
+ {
+ TBool needsCompletion;
+ iRequestStatus[aReqNo] = aStatus;
+
+ if (aReqNo > KUsbcMaxEpNumber)
+ {
+ r = DoOtherAsyncReq(aReqNo, a1, a2, needsCompletion);
+ if (needsCompletion)
+ {
+ switch (aReqNo)
+ {
+ case RDevUsbcClient::ERequestEndpointStatusNotify:
+ iRequestStatus[aReqNo]=NULL;
+ Kern::QueueRequestComplete(iClient,iEndpointStatusChangeReq,r);
+ break;
+ case RDevUsbcClient::ERequestOtgFeaturesNotify:
+ iRequestStatus[aReqNo]=NULL;
+ Kern::QueueRequestComplete(iClient,iOtgFeatureChangeReq,r);
+ break;
+ case RDevUsbcClient::ERequestAlternateDeviceStatusNotify:
+ iRequestStatus[aReqNo]=NULL;
+ Kern::QueueRequestComplete(iClient,iStatusChangeReq,r);
+ break;
+ case RDevUsbcClient::ERequestReEnumerate:
+ iRequestStatus[aReqNo]=NULL;
+ Kern::QueueBufferRequestComplete(iClient, iClientAsynchNotify[aReqNo]->iBufferRequest, r);
+ break;
+ }
+ }
+ }
+ else
+ {
+ r = DoTransferAsyncReq(aReqNo, a1, a2, needsCompletion);
+ if (needsCompletion)
+ {
+ //Kern::RequestComplete(iClient, iRequestStatus[aReqNo], r);
+ CompleteBufferRequest(iClient, aReqNo, r);
+ }
+ }
+ }
+ }
+
+
+
+TInt DLddUsbcChannel::DoOtherAsyncReq(TInt aReqNo, TAny* a1, TAny* a2, TBool& aNeedsCompletion)
+ {
+ // The general assumption is that none of these will complete now.
+ // However, those that make this function return something other than
+ // KErrNone will get completed by the calling function.
+ // So, 1) If you are returning KErrNone but really need to complete because
+ // completion criteria can be met (for example, sufficient data is
+ // available in the buffer) and then set aNeedsCompletion = ETrue.
+ // 2) Do NOT complete here AT ALL.
+ //
+ aNeedsCompletion = EFalse;
+ TInt r = KErrNone;
+
+ switch (aReqNo)
+ {
+ case RDevUsbcClient::ERequestAlternateDeviceStatusNotify:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlReqDeviceStatusNotify"));
+ if (a1 != NULL)
+ {
+ iDeviceStatusNeeded = ETrue;
+ iStatusChangePtr = a1;
+ aNeedsCompletion = AlternateDeviceStateTestComplete();
+ }
+ else
+ r = KErrArgument;
+ break;
+ }
+ case RDevUsbcClient::ERequestReEnumerate:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("ERequestReEnumerate"));
+ // If successful, this will complete via the status notification.
+ r = iController->ReEnumerate();
+ break;
+ }
+ case RDevUsbcClient::ERequestEndpointStatusNotify:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("ERequestEndpointStatusNotify"));
+ if (a1 != NULL)
+ {
+ iEndpointStatusChangePtr = a1;
+ }
+ else
+ r = KErrArgument;
+ break;
+ }
+ case RDevUsbcClient::ERequestOtgFeaturesNotify:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("ERequestOtgFeaturesNotify"));
+ if (a1 != NULL)
+ {
+ iOtgFeatureChangePtr = a1;
+ }
+ else
+ r = KErrArgument;
+ break;
+ }
+ default:
+ r = KErrNotSupported;
+ }
+
+ aNeedsCompletion = aNeedsCompletion || (r != KErrNone);
+
+ return r;
+ }
+
+
+TInt DLddUsbcChannel::DoTransferAsyncReq(TInt aEndpointNum, TAny* a1, TAny* a2, TBool& aNeedsCompletion)
+ {
+ // The general assumption is that none of these will complete now.
+ // however, those that are returning something other than KErrNone will get completed
+ // by the calling function.
+ // So, 1) if you are returning KErrNone but really need to complete because completion criteria can be met
+ // (for example, sufficient data is available in the buffer) and then set aNeedsCompletion=ETrue..
+ // 2) Do NOT complete here AT ALL.
+ //
+ aNeedsCompletion = EFalse;
+ TInt r = KErrNone;
+ TUsbcEndpoint* pEndpoint = NULL;
+ TUsbcEndpointInfo* pEndpointInfo = NULL;
+ TEndpointTransferInfo* pTfr = NULL;
+
+ if (aEndpointNum == 0)
+ {
+ // ep0 requests
+ if (!(iValidInterface || iOwnsDeviceControl))
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoRequest rejected: not configured (Ep0)"));
+ r = KErrUsbInterfaceNotReady;
+ goto exit;
+ }
+ }
+ else
+ {
+ // other eps
+ if (!(iValidInterface && (iDeviceState == UsbShai::EUsbPeripheralStateConfigured ||
+ iDeviceState == UsbShai::EUsbPeripheralStateSuspended))
+ )
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoRequest rejected not configured (Ep %d)", aEndpointNum));
+ r = KErrUsbInterfaceNotReady;
+ goto exit;
+ }
+ }
+
+ if (!ValidEndpoint(aEndpointNum))
+ {
+ __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoRequest Read: in error complete"));
+ r = KErrUsbEpNotInInterface;
+ goto exit;
+ }
+
+ if (a1 == NULL)
+ {
+ r = KErrArgument;
+ goto exit;
+ }
+ pTfr = (TEndpointTransferInfo *)a1;
+
+ if (pTfr->iTransferSize < 0)
+ {
+ r = KErrArgument;
+ goto exit;
+ }
+ pEndpoint = iEndpoint[aEndpointNum];
+ if (!pEndpoint)
+ {
+ __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoRequest Read: in error complete"));
+ r = KErrUsbEpNotInInterface;
+ goto exit;
+ }
+
+ pEndpointInfo = pEndpoint->EndpointInfo();
+ __KTRACE_OPT(KUSB, Kern::Printf("DoRequest %d", aEndpointNum));
+
+ switch (pTfr->iTransferType)
+ {
+
+ case ETransferTypeReadData:
+ case ETransferTypeReadPacket:
+ case ETransferTypeReadUntilShort:
+ case ETransferTypeReadOneOrMore:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read"));
+ if (pEndpoint->iDmaBuffers->RxIsActive())
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("**** ReadReq ep%d RxActive", aEndpointNum));
+ }
+ else
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("**** ReadReq ep%d RxInActive", aEndpointNum));
+ }
+
+ if (pEndpointInfo->iDir != UsbShai::KUsbEpDirOut &&
+ pEndpointInfo->iDir != UsbShai::KUsbEpDirBidirect)
+ {
+ // Trying to do the wrong thing
+ __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoRequest Read: in error complete"));
+ r = KErrUsbEpBadDirection;
+ break;
+ }
+ // Set the length of data to zero now to catch all cases
+ TPtrC8 pZeroDesc(NULL, 0);
+ r=Kern::ThreadBufWrite(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer, pZeroDesc, 0, 0,iClient);
+ if (r != KErrNone)
+ PanicClientThread(r);
+ pEndpoint->SetTransferInfo(pTfr);
+ if (pEndpoint->iDmaBuffers->IsReaderEmpty())
+ {
+ pEndpoint->SetClientReadPending(ETrue);
+ }
+ else
+ {
+ if (pTfr->iTransferType == ETransferTypeReadPacket)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read packet: data available complete"));
+ r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer);
+ aNeedsCompletion = ETrue;
+ break;
+ }
+ else if (pTfr->iTransferType == ETransferTypeReadData)
+ {
+ if (pTfr->iTransferSize <= pEndpoint->RxBytesAvailable())
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read data: data available complete"));
+ r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer);
+ aNeedsCompletion = ETrue;
+ break;
+ }
+ else
+ {
+ pEndpoint->SetClientReadPending(ETrue);
+ }
+ }
+ else if (pTfr->iTransferType == ETransferTypeReadOneOrMore)
+ {
+ if (pEndpoint->RxBytesAvailable() > 0)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read data: data available complete"));
+ r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer);
+ aNeedsCompletion = ETrue;
+ break;
+ }
+ else
+ {
+ pEndpoint->SetClientReadPending(ETrue);
+ }
+ }
+ else if (pTfr->iTransferType == ETransferTypeReadUntilShort)
+ {
+ TInt nRx = pEndpoint->RxBytesAvailable();
+ TInt maxPacketSize = pEndpoint->EndpointInfo()->iSize;
+ if( (pTfr->iTransferSize <= nRx) ||
+ (nRx < maxPacketSize) ||
+ pEndpoint->iDmaBuffers->ShortPacketExists())
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read data: data available complete"));
+ r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer);
+ aNeedsCompletion = ETrue;
+ }
+ else
+ {
+ pEndpoint->SetClientReadPending(ETrue);
+ }
+ }
+ }
+ r = pEndpoint->TryToStartRead(EFalse);
+ if (r != KErrNone)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read: couldn't start read"));
+ r = KErrNone; // Reader full isn't a userside error;
+ }
+ break;
+ }
+
+ case ETransferTypeWrite:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Write 1"));
+ if (pEndpointInfo->iDir != UsbShai::KUsbEpDirIn &&
+ pEndpointInfo->iDir != UsbShai::KUsbEpDirBidirect)
+ {
+ __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoRequest Write: wrong direction complete"));
+ r = KErrUsbEpBadDirection;
+ break;
+ }
+ __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Write 2"));
+
+
+ TInt desLength=iClientAsynchNotify[aEndpointNum]->iClientBuffer->Length();
+
+ if (desLength < pTfr->iTransferSize)
+ {
+ __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoRequest Write: user buffer too short"));
+ r = KErrUsbTransferSize;
+ break;
+ }
+
+ __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Write 3 length=%d maxlength=%d",
+ pTfr->iTransferSize, desLength));
+ // Zero length writes are acceptable
+ pEndpoint->SetClientWritePending(ETrue);
+ r = pEndpoint->TryToStartWrite(pTfr);
+ if (r != KErrNone)
+ {
+ __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoRequest Write: couldn't start write"));
+ pEndpoint->SetClientWritePending(EFalse);
+ }
+ break;
+ }
+
+ default:
+ __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoTransferAsyncReq: pTfr->iTransferType = %d not supported",
+ pTfr->iTransferType));
+ r = KErrNotSupported;
+ break;
+ }
+ exit:
+ aNeedsCompletion = aNeedsCompletion || (r != KErrNone);
+ return r;
+ }
+
+
+//
+// Cancel an outstanding request - overriding pure virtual
+//
+TInt DLddUsbcChannel::DoCancel(TInt aReqNo)
+ {
+ TInt r = KErrNone;
+ __KTRACE_OPT(KUSB, Kern::Printf("DoCancel: 0x%x", aReqNo));
+ if (aReqNo <= iNumberOfEndpoints)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoCancel endpoint: 0x%x", aReqNo));
+ iEndpoint[aReqNo]->CancelTransfer(iClient,iClientAsynchNotify[aReqNo]->iClientBuffer);
+ }
+ else if (aReqNo == RDevUsbcClient::ERequestAlternateDeviceStatusNotify)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoCancel: ERequestAlternateDeviceStatusNotify 0x%x", aReqNo));
+ iDeviceStatusNeeded = EFalse;
+ iStatusFifo->FlushQueue();
+ if (iStatusChangePtr)
+ {
+ iStatusChangeReq->Data()=iController->GetDeviceStatus();
+ iStatusChangePtr = NULL;
+
+ if (iStatusChangeReq->IsReady())
+ {
+ iRequestStatus[aReqNo] = NULL;
+ Kern::QueueRequestComplete(iClient, iStatusChangeReq, KErrCancel);
+ }
+ return KErrNone;
+ }
+ }
+ else if (aReqNo == RDevUsbcClient::ERequestReEnumerate)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoCancel ERequestReEnumerate: 0x%x", aReqNo));
+ }
+ else if (aReqNo == RDevUsbcClient::ERequestEndpointStatusNotify)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoCancel ERequestEndpointStatusNotify: 0x%x", aReqNo));
+ CancelNotifyEndpointStatus();
+ if (iEndpointStatusChangeReq->IsReady())
+ {
+ iRequestStatus[aReqNo] = NULL;
+ Kern::QueueRequestComplete(iClient, iEndpointStatusChangeReq, KErrCancel);
+ }
+ return KErrNone;
+ }
+ else if (aReqNo == RDevUsbcClient::ERequestOtgFeaturesNotify)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoCancel ERequestOtgFeaturesNotify: 0x%x", aReqNo));
+ CancelNotifyOtgFeatures();
+ if (iOtgFeatureChangeReq->IsReady())
+ {
+ iRequestStatus[aReqNo] = NULL;
+ Kern::QueueRequestComplete(iClient, iOtgFeatureChangeReq, KErrCancel);
+ }
+ }
+ else
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoCancel Unknown! 0x%x", aReqNo));
+ }
+
+ if (r == KErrNone)
+ r = KErrCancel;
+
+ CompleteBufferRequest(iClient, aReqNo, r);
+ return r;
+ }
+
+
+void DLddUsbcChannel::CancelNotifyEndpointStatus()
+ {
+ if (iEndpointStatusChangePtr)
+ {
+ TUint epBitmap = 0;
+ for (TInt i = 0; i <= iNumberOfEndpoints; i++)
+ {
+ TInt v = iController->GetEndpointStatus(this, iEndpoint[i]->RealEpNumber());
+ TUint b;
+ (v == EEndpointStateStalled) ? b = 1 : b = 0;
+ epBitmap |= b << i;
+ }
+ iEndpointStatusChangeReq->Data()=epBitmap;
+ iEndpointStatusChangePtr = NULL;
+ }
+ }
+
+
+void DLddUsbcChannel::CancelNotifyOtgFeatures()
+ {
+ if (iOtgFeatureChangePtr)
+ {
+ TUint8 features;
+ iController->GetCurrentOtgFeatures(features);
+ iOtgFeatureChangeReq->Data()=features;
+ iOtgFeatureChangePtr = NULL;
+ }
+ }
+
+TInt DLddUsbcChannel::PinMemory(TDesC8 *aDes, TVirtualPinObject *aPinObj)
+ {
+ TInt r = KErrNone;
+ TInt len,mlen;
+
+ const TUint8*p = Kern::KUDesInfo(*aDes, len,mlen);
+ r=Kern::PinVirtualMemory(aPinObj, (TLinAddr) p, len);
+ return r;
+ }
+
+//Called in Client thread context
+TInt DLddUsbcChannel::SendControl(TMessageBase* aMsg)
+ {
+ TThreadMessage& m=*(TThreadMessage*)aMsg;
+ const TInt fn=m.iValue;
+ TAny *const a1=m.Ptr0();
+ TAny *const a2=m.Ptr1();
+ TInt kern_param;
+ TEndpointDescriptorInfo epi;
+ TUsbcIfcInfo ifc;
+ TCSDescriptorInfo desInfo;
+ TInt r = KErrNone;
+
+ switch (fn)
+ {
+
+ case RDevUsbcClient::EControlDeviceStatus:
+ case RDevUsbcClient::EControlGetAlternateSetting:
+ m.iArg[0] = &kern_param; // update message to point to kernel-side buffer
+ break;
+
+ case RDevUsbcClient::EControlQueryReceiveBuffer:
+ case RDevUsbcClient::EControlEndpointStatus:
+ m.iArg[1] = &kern_param; // update message to point to kernel-side buffer
+ break;
+
+ case RDevUsbcClient::EControlEndpointCaps:
+ case RDevUsbcClient::EControlDeviceCaps:
+ case RDevUsbcClient::EControlGetDeviceDescriptor:
+ case RDevUsbcClient::EControlSetDeviceDescriptor:
+ case RDevUsbcClient::EControlGetDeviceDescriptorSize:
+ case RDevUsbcClient::EControlGetConfigurationDescriptor:
+ case RDevUsbcClient::EControlGetConfigurationDescriptorSize:
+ case RDevUsbcClient::EControlGetDeviceQualifierDescriptor:
+ case RDevUsbcClient::EControlSetDeviceQualifierDescriptor:
+ case RDevUsbcClient::EControlGetOtherSpeedConfigurationDescriptor:
+ case RDevUsbcClient::EControlSetOtherSpeedConfigurationDescriptor:
+ case RDevUsbcClient::EControlGetStringDescriptorLangId:
+ case RDevUsbcClient::EControlGetManufacturerStringDescriptor:
+ case RDevUsbcClient::EControlSetManufacturerStringDescriptor:
+ case RDevUsbcClient::EControlGetProductStringDescriptor:
+ case RDevUsbcClient::EControlSetProductStringDescriptor:
+ case RDevUsbcClient::EControlGetSerialNumberStringDescriptor:
+ case RDevUsbcClient::EControlSetSerialNumberStringDescriptor:
+ case RDevUsbcClient::EControlGetConfigurationStringDescriptor:
+ case RDevUsbcClient::EControlSetConfigurationStringDescriptor:
+ case RDevUsbcClient::EControlSetOtgDescriptor:
+ case RDevUsbcClient::EControlGetOtgDescriptor:
+ case RDevUsbcClient::EControlGetOtgFeatures:
+ r=PinMemory((TDesC8 *) a1, iPinObj1);
+ if(r!=KErrNone)
+ {
+ PanicClientThread(r);
+ return r;
+ }
+ break;
+
+ case RDevUsbcClient::EControlGetInterfaceDescriptor:
+ case RDevUsbcClient::EControlGetInterfaceDescriptorSize:
+ case RDevUsbcClient::EControlSetInterfaceDescriptor:
+ case RDevUsbcClient::EControlGetCSInterfaceDescriptor:
+ case RDevUsbcClient::EControlGetCSInterfaceDescriptorSize:
+ case RDevUsbcClient::EControlGetStringDescriptor:
+ case RDevUsbcClient::EControlSetStringDescriptor:
+ r=PinMemory((TDesC8 *) a2, iPinObj1);
+ if(r!=KErrNone)
+ {
+ PanicClientThread(r);
+ return r;
+ }
+ break;
+
+ case RDevUsbcClient::EControlGetEndpointDescriptor:
+ case RDevUsbcClient::EControlGetEndpointDescriptorSize:
+ case RDevUsbcClient::EControlSetEndpointDescriptor:
+ case RDevUsbcClient::EControlGetCSEndpointDescriptor:
+ case RDevUsbcClient::EControlGetCSEndpointDescriptorSize:
+ if(a1!=NULL)
+ {
+ r=Kern::PinVirtualMemory(iPinObj1, (TLinAddr)a1, sizeof(epi));
+ if(r!=KErrNone)
+ {
+ PanicClientThread(r);
+ return r;
+ }
+ kumemget(&epi, a1, sizeof(epi));
+ r=PinMemory((TDesC8 *) epi.iArg, iPinObj2);
+ if(r!=KErrNone)
+ {
+ Kern::UnpinVirtualMemory(iPinObj1);
+ PanicClientThread(r);
+ return r;
+ }
+ }
+ break;
+
+ case RDevUsbcClient::EControlSetInterface:
+ if(a2!=NULL)
+ {
+ r=Kern::PinVirtualMemory(iPinObj1, (TLinAddr)a2, sizeof(ifc));
+ if(r!=KErrNone)
+ {
+ PanicClientThread(r);
+ return r;
+ }
+ kumemget(&ifc, a2, sizeof(ifc));
+ r=PinMemory((TDesC8 *) ifc.iInterfaceData, iPinObj2);
+ if(r!=KErrNone)
+ {
+ Kern::UnpinVirtualMemory(iPinObj1);
+ PanicClientThread(r);
+ return r;
+ }
+ }
+ break;
+
+ case RDevUsbcClient::EControlSetCSInterfaceDescriptor:
+ case RDevUsbcClient::EControlSetCSEndpointDescriptor:
+ if(a1!=NULL)
+ {
+ r=Kern::PinVirtualMemory(iPinObj1, (TLinAddr)a1, sizeof(desInfo));
+ if(r!=KErrNone)
+ {
+ PanicClientThread(r);
+ return r;
+ }
+ kumemget(&desInfo, a1, sizeof(desInfo));
+ r=PinMemory((TDesC8 *) desInfo.iArg, iPinObj2);
+ if(r!=KErrNone)
+ {
+ Kern::UnpinVirtualMemory(iPinObj1);
+ PanicClientThread(r);
+ return r;
+ }
+ }
+ break;
+ }
+
+
+ //Send Message and wait for synchronous complete
+ r = DLogicalChannel::SendMsg(aMsg);
+
+
+
+ switch (fn)
+ {
+ case RDevUsbcClient::EControlDeviceStatus:
+ case RDevUsbcClient::EControlGetAlternateSetting:
+ umemput32(a1, &kern_param, sizeof(kern_param));
+ break;
+
+ case RDevUsbcClient::EControlQueryReceiveBuffer:
+ case RDevUsbcClient::EControlEndpointStatus:
+ umemput32(a2, &kern_param, sizeof(kern_param));
+ break;
+
+ case RDevUsbcClient::EControlDeviceCaps:
+ case RDevUsbcClient::EControlEndpointCaps:
+ case RDevUsbcClient::EControlGetDeviceDescriptor:
+ case RDevUsbcClient::EControlSetDeviceDescriptor:
+ case RDevUsbcClient::EControlGetDeviceDescriptorSize:
+ case RDevUsbcClient::EControlGetConfigurationDescriptor:
+ case RDevUsbcClient::EControlGetConfigurationDescriptorSize:
+ case RDevUsbcClient::EControlGetDeviceQualifierDescriptor:
+ case RDevUsbcClient::EControlSetDeviceQualifierDescriptor:
+ case RDevUsbcClient::EControlGetOtherSpeedConfigurationDescriptor:
+ case RDevUsbcClient::EControlSetOtherSpeedConfigurationDescriptor:
+ case RDevUsbcClient::EControlGetStringDescriptorLangId:
+ case RDevUsbcClient::EControlGetManufacturerStringDescriptor:
+ case RDevUsbcClient::EControlSetManufacturerStringDescriptor:
+ case RDevUsbcClient::EControlGetProductStringDescriptor:
+ case RDevUsbcClient::EControlSetProductStringDescriptor:
+ case RDevUsbcClient::EControlGetSerialNumberStringDescriptor:
+ case RDevUsbcClient::EControlSetSerialNumberStringDescriptor:
+ case RDevUsbcClient::EControlGetConfigurationStringDescriptor:
+ case RDevUsbcClient::EControlSetConfigurationStringDescriptor:
+ case RDevUsbcClient::EControlSetOtgDescriptor:
+ case RDevUsbcClient::EControlGetOtgDescriptor:
+ case RDevUsbcClient::EControlGetOtgFeatures:
+ if(a1!=NULL)
+ {
+ Kern::UnpinVirtualMemory(iPinObj1);
+ }
+ break;
+
+ case RDevUsbcClient::EControlGetInterfaceDescriptor:
+ case RDevUsbcClient::EControlGetInterfaceDescriptorSize:
+ case RDevUsbcClient::EControlSetInterfaceDescriptor:
+ case RDevUsbcClient::EControlGetCSInterfaceDescriptor:
+ case RDevUsbcClient::EControlGetCSInterfaceDescriptorSize:
+ case RDevUsbcClient::EControlGetStringDescriptor:
+ case RDevUsbcClient::EControlSetStringDescriptor:
+ if(a2!=NULL)
+ {
+ Kern::UnpinVirtualMemory(iPinObj1);
+ }
+ break;
+
+ case RDevUsbcClient::EControlGetEndpointDescriptor:
+ case RDevUsbcClient::EControlGetEndpointDescriptorSize:
+ case RDevUsbcClient::EControlSetEndpointDescriptor:
+ case RDevUsbcClient::EControlGetCSEndpointDescriptor:
+ case RDevUsbcClient::EControlGetCSEndpointDescriptorSize:
+ case RDevUsbcClient::EControlSetCSInterfaceDescriptor:
+ case RDevUsbcClient::EControlSetCSEndpointDescriptor:
+ if(a1!=NULL)
+ {
+ Kern::UnpinVirtualMemory(iPinObj1);
+ Kern::UnpinVirtualMemory(iPinObj2);
+ }
+ break;
+
+ case RDevUsbcClient::EControlSetInterface:
+ if(a2!=NULL)
+ {
+ Kern::UnpinVirtualMemory(iPinObj1);
+ Kern::UnpinVirtualMemory(iPinObj2);
+ }
+ break;
+ }
+
+ return r;
+ }
+
+
+TInt DLddUsbcChannel::DoControl(TInt aFunction, TAny* a1, TAny* a2)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoControl: %d", aFunction));
+
+ TInt r = KErrNone;
+ TInt ep;
+ TUsbcEndpoint* pEndpoint;
+ TPtrC8 pZeroDesc(NULL, 0);
+ TEndpointDescriptorInfo epInfo;
+ TUsbcIfcInfo ifcInfo;
+ TCSDescriptorInfo desInfo;
+ TUsbcEndpointResource epRes;
+ TInt bandwidthPriority;
+
+ switch (aFunction)
+ {
+ case RDevUsbcClient::EControlEndpointZeroRequestError:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlEndpointZeroRequestError"));
+ r = KErrNone;
+ if (iOwnsDeviceControl || (iValidInterface && iDeviceState == UsbShai::EUsbPeripheralStateConfigured))
+ {
+ iController->Ep0Stall(this);
+ }
+ else
+ {
+ if (iDeviceState != UsbShai::EUsbPeripheralStateConfigured)
+ r = KErrUsbDeviceNotConfigured;
+ else
+ r = KErrUsbInterfaceNotReady;
+ }
+ break;
+
+ case RDevUsbcClient::EControlGetAlternateSetting:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetAlternateSetting"));
+ if (iValidInterface && iDeviceState == UsbShai::EUsbPeripheralStateConfigured)
+ {
+ r = iController->GetInterfaceNumber(this, *(TInt*)a1);
+ }
+ else
+ {
+ if (iDeviceState != UsbShai::EUsbPeripheralStateConfigured)
+ r = KErrUsbDeviceNotConfigured;
+ else
+ r = KErrUsbInterfaceNotReady;
+ }
+ break;
+
+ case RDevUsbcClient::EControlDeviceStatus:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlDeviceStatus"));
+ *(TInt*)a1 = iController->GetDeviceStatus();
+ break;
+
+ case RDevUsbcClient::EControlEndpointStatus:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlEndpointStatus"));
+ if (iValidInterface && ValidEndpoint((TInt) a1))
+ {
+ pEndpoint = iEndpoint[(TInt)a1];
+ if (pEndpoint == NULL)
+ r = KErrNotSupported;
+ else
+ {
+ *(TInt*)a2 = iController->GetEndpointStatus(this, iEndpoint[(TInt)a1]->RealEpNumber());
+ }
+ }
+ else
+ {
+ if (iDeviceState != UsbShai::EUsbPeripheralStateConfigured)
+ r = KErrUsbDeviceNotConfigured;
+ else
+ r = KErrUsbInterfaceNotReady;
+ }
+ break;
+
+ case RDevUsbcClient::EControlQueryReceiveBuffer:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlQueryReceiveBuffer"));
+ if (iValidInterface && ValidEndpoint((TInt) a1))
+ {
+ pEndpoint=iEndpoint[(TInt) a1];
+ if (pEndpoint == NULL)
+ r = KErrNotSupported;
+ else if (pEndpoint->EndpointInfo()->iDir != UsbShai::KUsbEpDirIn)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" bytes = %d", pEndpoint->RxBytesAvailable()));
+ *(TInt*)a2 = pEndpoint->RxBytesAvailable();
+ }
+ }
+ else
+ {
+ if (iDeviceState != UsbShai::EUsbPeripheralStateConfigured)
+ r = KErrUsbDeviceNotConfigured;
+ else
+ r = KErrUsbInterfaceNotReady;
+ }
+ break;
+
+ case RDevUsbcClient::EControlEndpointCaps:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlEndpointCaps"));
+ r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient);
+ if (r != KErrNone)
+ PanicClientThread(r);
+ iController->EndpointCaps(this, *((TDes8*) a1));
+ break;
+
+ case RDevUsbcClient::EControlDeviceCaps:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlDeviceCaps"));
+ r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient);
+ if (r != KErrNone)
+ PanicClientThread(r);
+ iController->DeviceCaps(this, *((TDes8*) a1));
+ break;
+
+ case RDevUsbcClient::EControlSendEp0StatusPacket:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSendEp0StatusPacket"));
+ iController->SendEp0StatusPacket(this);
+ break;
+
+ case RDevUsbcClient::EControlHaltEndpoint:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlHaltEndpoint"));
+ if (iValidInterface && ValidEndpoint((TInt) a1))
+ {
+ r = iController->HaltEndpoint(this, iEndpoint[(TInt)a1]->RealEpNumber());
+ }
+ else
+ {
+ if (iDeviceState != UsbShai::EUsbPeripheralStateConfigured)
+ r = KErrUsbDeviceNotConfigured;
+ else
+ r = KErrUsbInterfaceNotReady;
+ }
+ break;
+
+ case RDevUsbcClient::EControlClearHaltEndpoint:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlClearHaltEndpoint"));
+ if (iValidInterface && ValidEndpoint((TInt) a1))
+ {
+ r = iController->ClearHaltEndpoint(this, iEndpoint[(TInt)a1]->RealEpNumber());
+ }
+ else
+ {
+ if (iDeviceState != UsbShai::EUsbPeripheralStateConfigured)
+ r = KErrUsbDeviceNotConfigured;
+ else
+ r = KErrUsbInterfaceNotReady;
+ }
+ break;
+
+ case RDevUsbcClient::EControlDumpRegisters:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlDumpRegisters"));
+ iController->DumpRegisters();
+ break;
+
+ case RDevUsbcClient::EControlReleaseDeviceControl:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlReleaseDeviceControl"));
+ iController->ReleaseDeviceControl(this);
+ iOwnsDeviceControl = EFalse;
+ break;
+
+ case RDevUsbcClient::EControlEndpointZeroMaxPacketSizes:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlEndpointZeroMaxPacketSizes"));
+ r = iController->EndpointZeroMaxPacketSizes();
+ break;
+
+ case RDevUsbcClient::EControlSetEndpointZeroMaxPacketSize:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetEndpointZeroMaxPacketSize"));
+ r = iController->SetEndpointZeroMaxPacketSize(reinterpret_cast<TInt>(a1));
+ break;
+
+ case RDevUsbcClient::EControlGetEndpointZeroMaxPacketSize:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetEndpointZeroMaxPacketSize"));
+ r = iController->Ep0PacketSize();
+ break;
+
+ case RDevUsbcClient::EControlGetDeviceDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetDeviceDescriptor"));
+ r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient);
+ if (r != KErrNone)
+ PanicClientThread(r);
+ r = iController->GetDeviceDescriptor(iClient, *((TDes8*) a1));
+ break;
+
+ case RDevUsbcClient::EControlSetDeviceDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetDeviceDescriptor"));
+ if (a1 != NULL)
+ r = iController->SetDeviceDescriptor(iClient, *((TDes8*) a1));
+ else
+ r = KErrArgument;
+ break;
+
+ case RDevUsbcClient::EControlGetDeviceDescriptorSize:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetDeviceDescriptorSize"));
+ if (a1 != NULL)
+ r = iController->GetDeviceDescriptorSize(iClient, *((TDes8*) a1));
+ else
+ r = KErrArgument;
+ break;
+
+ case RDevUsbcClient::EControlGetConfigurationDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetConfigurationDescriptor"));
+ r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0 , 0, iClient);
+ if (r != KErrNone)
+ PanicClientThread(r);
+ r = iController->GetConfigurationDescriptor(iClient, *((TDes8*) a1));
+ break;
+
+ case RDevUsbcClient::EControlGetConfigurationDescriptorSize:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetConfigurationDescriptorSize"));
+ if (a1 != NULL)
+ {
+ r = iController->GetConfigurationDescriptorSize(iClient, *((TDes8*) a1));
+ }
+ else
+ r = KErrArgument;
+ break;
+
+ case RDevUsbcClient::EControlSetConfigurationDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetConfigurationDescriptor"));
+ r = iController->SetConfigurationDescriptor(iClient, *((TDes8*) a1));
+ break;
+
+ case RDevUsbcClient::EControlGetInterfaceDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetInterfaceDescriptor"));
+ r = iController->GetInterfaceDescriptor(iClient, this, (TInt) a1, *((TDes8*) a2));
+ break;
+
+ case RDevUsbcClient::EControlGetInterfaceDescriptorSize:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetInterfaceDescriptorSize"));
+ r = iController->GetInterfaceDescriptorSize(iClient, this, (TInt) a1, *(TDes8*) a2);
+ break;
+
+ case RDevUsbcClient::EControlSetInterfaceDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetInterfaceDescriptor"));
+ r = iController->SetInterfaceDescriptor(iClient, this, (TInt) a1, *((TDes8*) a2));
+ break;
+
+ case RDevUsbcClient::EControlGetEndpointDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetEndpointDescriptor"));
+ r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo));
+ if (r != KErrNone)
+ PanicClientThread(r);
+ ep = EpFromAlternateSetting(epInfo.iSetting, epInfo.iEndpoint);
+ r = iController->GetEndpointDescriptor(iClient, this, epInfo.iSetting,
+ ep, *(TDes8*) epInfo.iArg);
+ break;
+
+ case RDevUsbcClient::EControlGetEndpointDescriptorSize:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetEndpointDescriptorSize"));
+ r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo));
+ if (r != KErrNone)
+ PanicClientThread(r);
+ ep = EpFromAlternateSetting(epInfo.iSetting, epInfo.iEndpoint);
+ r = iController->GetEndpointDescriptorSize(iClient, this, epInfo.iSetting,
+ ep, *(TDes8*) epInfo.iArg);
+ break;
+
+ case RDevUsbcClient::EControlSetEndpointDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetEndpointDescriptor"));
+ r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo));
+ if (r != KErrNone)
+ PanicClientThread(r);
+ ep = EpFromAlternateSetting(epInfo.iSetting, epInfo.iEndpoint);
+ r = iController->SetEndpointDescriptor(iClient, this, epInfo.iSetting,
+ ep, *(TDes8*)epInfo.iArg);
+ break;
+
+ case RDevUsbcClient::EControlGetDeviceQualifierDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetDeviceQualifierDescriptor"));
+ r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient);
+ if (r != KErrNone)
+ PanicClientThread(r);
+ r = iController->GetDeviceQualifierDescriptor(iClient, *((TDes8*) a1));
+ break;
+
+ case RDevUsbcClient::EControlSetDeviceQualifierDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetDeviceQualifierDescriptor"));
+ if (a1 != NULL)
+ r = iController->SetDeviceQualifierDescriptor(iClient, *((TDes8*) a1));
+ else
+ r = KErrArgument;
+ break;
+
+ case RDevUsbcClient::EControlGetOtherSpeedConfigurationDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetOtherSpeedConfigurationDescriptor"));
+ r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0 , 0, iClient);
+ if (r != KErrNone)
+ PanicClientThread(r);
+ r = iController->GetOtherSpeedConfigurationDescriptor(iClient, *((TDes8*) a1));
+ break;
+
+ case RDevUsbcClient::EControlSetOtherSpeedConfigurationDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetOtherSpeedConfigurationDescriptor"));
+ r = iController->SetOtherSpeedConfigurationDescriptor(iClient, *((TDes8*) a1));
+ break;
+
+
+ case RDevUsbcClient::EControlGetCSInterfaceDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetCSInterfaceDescriptor"));
+ r = iController->GetCSInterfaceDescriptorBlock(iClient, this, (TInt) a1, *((TDes8*) a2));
+ break;
+
+ case RDevUsbcClient::EControlGetCSInterfaceDescriptorSize:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetCSInterfaceDescriptorSize"));
+ r = iController->GetCSInterfaceDescriptorBlockSize(iClient, this, (TInt) a1, *(TDes8*) a2);
+ break;
+
+ case RDevUsbcClient::EControlGetCSEndpointDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetCSEndpointDescriptor"));
+ r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo));
+ if (r != KErrNone)
+ PanicClientThread(r);
+ ep = EpFromAlternateSetting(epInfo.iSetting, epInfo.iEndpoint);
+ r = iController->GetCSEndpointDescriptorBlock(iClient, this, epInfo.iSetting,
+ ep, *(TDes8*) epInfo.iArg);
+ break;
+
+ case RDevUsbcClient::EControlGetCSEndpointDescriptorSize:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetCSEndpointDescriptorSize"));
+ r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo));
+ if (r != KErrNone)
+ PanicClientThread(r);
+ ep = EpFromAlternateSetting(epInfo.iSetting, epInfo.iEndpoint);
+ r = iController->GetCSEndpointDescriptorBlockSize(iClient, this, epInfo.iSetting,
+ ep, *(TDes8*) epInfo.iArg);
+ break;
+
+ case RDevUsbcClient::EControlSignalRemoteWakeup:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSignalRemoteWakeup"));
+ r = iController->SignalRemoteWakeup();
+ break;
+
+ case RDevUsbcClient::EControlDeviceDisconnectFromHost:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlDeviceDisconnectFromHost"));
+ r = iController->UsbDisconnect();
+ break;
+
+ case RDevUsbcClient::EControlDeviceConnectToHost:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlDeviceConnectToHost"));
+ r = iController->UsbConnect();
+ break;
+
+ case RDevUsbcClient::EControlDevicePowerUpUdc:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlDevicePowerUpUdc"));
+ r = iController->PowerUpUdc();
+ break;
+
+ case RDevUsbcClient::EControlSetDeviceControl:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetDeviceControl"));
+ r = iController->SetDeviceControl(this);
+ if (r == KErrNone)
+ {
+ iOwnsDeviceControl = ETrue;
+ if (iEndpoint[0] == NULL)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetDeviceControl 11"));
+ r = SetupEp0();
+ if (r != KErrNone)
+ {
+ __KTRACE_OPT(KPANIC, Kern::Printf(" Error: SetupEp0() failed"));
+ iController->ReleaseDeviceControl(this);
+ DestroyEp0();
+ iOwnsDeviceControl = EFalse;
+ }
+ iEndpoint[0]->TryToStartRead(EFalse);
+ }
+ }
+ else
+ r = KErrInUse;
+ break;
+
+ case RDevUsbcClient::EControlCurrentlyUsingHighSpeed:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlCurrentlyUsingHighSpeed"));
+ r = iController->CurrentlyUsingHighSpeed();
+ break;
+
+ case RDevUsbcClient::EControlSetInterface:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetInterface"));
+ r = Kern::ThreadRawRead(iClient, a2, &ifcInfo, sizeof(ifcInfo));
+ if (r != KErrNone)
+ PanicClientThread(r);
+ if (iValidInterface && (iDeviceState == UsbShai::EUsbPeripheralStateConfigured))
+ {
+ r = KErrGeneral;
+ }
+ else
+ {
+ bandwidthPriority = ifcInfo.iBandwidthPriority;
+ if ((bandwidthPriority & 0xffffff00) ||
+ ((bandwidthPriority & 0x0f) >= KUsbcDmaBufMaxPriorities) ||
+ (((bandwidthPriority >> 4) & 0x0f) >= KUsbcDmaBufMaxPriorities))
+ {
+ r = KErrArgument;
+ }
+ else
+ {
+ r = SetInterface((TInt) a1, &ifcInfo);
+ }
+ }
+
+ break;
+
+ case RDevUsbcClient::EControlReleaseInterface:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlReleaseInterface"));
+ r = iController->ReleaseInterface(this, (TInt) a1);
+ if (r == KErrNone)
+ {
+ DestroyInterface((TUint) a1);
+ }
+ else
+ {
+ __KTRACE_OPT(KPANIC, Kern::Printf(" Error in PIL: LDD interface won't be released."));
+ }
+ break;
+
+ case RDevUsbcClient::EControlSetCSInterfaceDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetCSInterfaceDescriptor"));
+ r = Kern::ThreadRawRead(iClient, a1, &desInfo, sizeof(desInfo));
+ if (r != KErrNone)
+ PanicClientThread(r);
+ r = iController->SetCSInterfaceDescriptorBlock(iClient, this, desInfo.iSetting,
+ *reinterpret_cast<const TDes8*>(desInfo.iArg),
+ desInfo.iSize);
+ break;
+
+ case RDevUsbcClient::EControlSetCSEndpointDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetCSEndpointDescriptor"));
+ r = Kern::ThreadRawRead(iClient, a1, &desInfo, sizeof(desInfo));
+ if (r != KErrNone)
+ PanicClientThread(r);
+ ep = EpFromAlternateSetting(desInfo.iSetting, desInfo.iEndpoint);
+ r = iController->SetCSEndpointDescriptorBlock(iClient, this, desInfo.iSetting, ep,
+ *reinterpret_cast<const TDes8*>(desInfo.iArg),
+ desInfo.iSize);
+ break;
+
+ case RDevUsbcClient::EControlGetStringDescriptorLangId:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetStringDescriptorLangId"));
+ r = iController->GetStringDescriptorLangId(iClient, *((TDes8*) a1));
+ break;
+
+ case RDevUsbcClient::EControlSetStringDescriptorLangId:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetStringDescriptorLangId"));
+ r = iController->SetStringDescriptorLangId(reinterpret_cast<TUint>(a1));
+ break;
+
+ case RDevUsbcClient::EControlGetManufacturerStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetManufacturerStringDescriptor"));
+ r = iController->GetManufacturerStringDescriptor(iClient, *((TPtr8*) a1));
+ break;
+
+ case RDevUsbcClient::EControlSetManufacturerStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetManufacturerStringDescriptor"));
+ r = iController->SetManufacturerStringDescriptor(iClient, *((TPtr8*) a1));
+ break;
+
+ case RDevUsbcClient::EControlRemoveManufacturerStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveManufacturerStringDescriptor"));
+ r = iController->RemoveManufacturerStringDescriptor();
+ break;
+
+ case RDevUsbcClient::EControlGetProductStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetProductStringDescriptor"));
+ r = iController->GetProductStringDescriptor(iClient, *((TPtr8*) a1));
+ break;
+
+ case RDevUsbcClient::EControlSetProductStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetProductStringDescriptor"));
+ r = iController->SetProductStringDescriptor(iClient, *((TPtr8*) a1));
+ break;
+
+ case RDevUsbcClient::EControlRemoveProductStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveProductStringDescriptor"));
+ r = iController->RemoveProductStringDescriptor();
+ break;
+
+ case RDevUsbcClient::EControlGetSerialNumberStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetSerialNumberStringDescriptor"));
+ r = iController->GetSerialNumberStringDescriptor(iClient, *((TPtr8*) a1));
+ break;
+
+ case RDevUsbcClient::EControlSetSerialNumberStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetSerialNumberStringDescriptor"));
+ r = iController->SetSerialNumberStringDescriptor(iClient, *((TPtr8*) a1));
+ break;
+
+ case RDevUsbcClient::EControlRemoveSerialNumberStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveSerialNumberStringDescriptor"));
+ r = iController->RemoveSerialNumberStringDescriptor();
+ break;
+
+ case RDevUsbcClient::EControlGetConfigurationStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetConfigurationStringDescriptor"));
+ r = iController->GetConfigurationStringDescriptor(iClient, *((TPtr8*) a1));
+ break;
+
+ case RDevUsbcClient::EControlSetConfigurationStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetConfigurationStringDescriptor"));
+ r = iController->SetConfigurationStringDescriptor(iClient, *((TPtr8*) a1));
+ break;
+
+ case RDevUsbcClient::EControlRemoveConfigurationStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveConfigurationStringDescriptor"));
+ r = iController->RemoveConfigurationStringDescriptor();
+ break;
+
+ case RDevUsbcClient::EControlGetStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetStringDescriptor"));
+ r = iController->GetStringDescriptor(iClient, (TUint8) (TInt) a1, *((TPtr8*) a2));
+ break;
+
+ case RDevUsbcClient::EControlSetStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetStringDescriptor"));
+ r = iController->SetStringDescriptor(iClient, (TUint8) (TInt) a1, *((TPtr8*) a2));
+ break;
+
+ case RDevUsbcClient::EControlRemoveStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveStringDescriptor"));
+ r = iController->RemoveStringDescriptor((TUint8) (TInt) a1);
+ break;
+
+ case RDevUsbcClient::EControlQueryEndpointResourceUse:
+ epRes = (TUsbcEndpointResource)((TInt) a2);
+ if (!ValidEndpoint((TInt)a1))
+ {
+ r = KErrUsbEpNotInInterface;
+ }
+ else
+ {
+ r = iController->QueryEndpointResource(this, iEndpoint[(TInt)a1]->RealEpNumber(), epRes);
+ }
+ break;
+
+ case RDevUsbcClient::EControlSetOtgDescriptor:
+ {
+ r = iController->SetOtgDescriptor(iClient, *((const TDesC8*)a1));
+ }
+ break;
+
+ case RDevUsbcClient::EControlGetOtgDescriptor:
+ {
+ r = iController->GetOtgDescriptor(iClient, *((TDes8*)a1));
+ }
+ break;
+
+ case RDevUsbcClient::EControlGetOtgFeatures:
+ {
+ r = iController->GetOtgFeatures(iClient, *((TDes8*)a1));
+ }
+ break;
+
+ default:
+ __KTRACE_OPT(KUSB, Kern::Printf("Function code not supported"));
+ r = KErrNotSupported;
+ }
+
+ return r;
+ }
+
+
+TInt DLddUsbcChannel::SetInterface(TInt aInterfaceNumber, TUsbcIfcInfo* aInfoBuf)
+ {
+ TUsbcInterfaceInfoBuf ifc_info_buf;
+ TUsbcInterfaceInfoBuf* const ifc_info_buf_ptr = aInfoBuf->iInterfaceData;
+ const TInt srcLen = Kern::ThreadGetDesLength(iClient, ifc_info_buf_ptr);
+ if (srcLen < ifc_info_buf.Length())
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("SetInterface can't copy"));
+ PanicClientThread(EDesOverflow);
+ }
+
+ TInt r = Kern::ThreadDesRead(iClient, ifc_info_buf_ptr, ifc_info_buf, 0, KChunkShiftBy0);
+ if (r != KErrNone)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("SetInterface Copy failed reason=%d", r));
+ PanicClientThread(r);
+ }
+
+ TUsbcEndpointInfo* pEndpointData = ifc_info_buf().iEndpointData;
+
+ // If an alternate interface is being asked for then do nothing,
+ // just pass it down to the Controller.
+ const TInt num_endpoints = ifc_info_buf().iTotalEndpointsUsed;
+ __KTRACE_OPT(KUSB, Kern::Printf("SetInterface num_endpoints=%d", num_endpoints));
+
+ // [The next 4 variables have to be initialized here because of the goto's that follow.]
+ // Both IN and OUT buffers will be fully cached:
+ const TUint32 cacheAttribs = EMapAttrSupRw | EMapAttrCachedMax;
+ const TUint32 bandwidthPriority = aInfoBuf->iBandwidthPriority;
+
+ // Supports ep0+5 endpoints
+ TInt real_ep_numbers[6] = {-1, -1, -1, -1, -1, -1};
+
+ // See if PIL will accept this interface
+ __KTRACE_OPT(KUSB, Kern::Printf("SetInterface Calling controller"));
+ r = iController->SetInterface(this,
+ iClient,
+ aInterfaceNumber,
+ ifc_info_buf().iClass,
+ aInfoBuf->iString,
+ ifc_info_buf().iTotalEndpointsUsed,
+ ifc_info_buf().iEndpointData,
+ &real_ep_numbers,
+ ifc_info_buf().iFeatureWord);
+
+ __KTRACE_OPT(KUSB, Kern::Printf("SetInterface controller returned %d", r));
+ if (r != KErrNone)
+ {
+ __KTRACE_OPT(KPANIC, Kern::Printf("SetInterface failed reason=%d", r));
+ return r;
+ }
+
+ // [The next variable has to be initialized here because of the goto's that follow.]
+ TUsbcAlternateSettingList* alternateSettingListRec;
+
+ // ep0
+ if (iEndpoint[0] == NULL)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("SetInterface 11"));
+ r = SetupEp0();
+ if (r != KErrNone)
+ {
+ __KTRACE_OPT(KPANIC, Kern::Printf(" Error: SetupEp0() failed"));
+ DestroyEp0();
+ goto F1;
+ }
+ }
+
+ alternateSettingListRec = new TUsbcAlternateSettingList;
+ if (!alternateSettingListRec)
+ {
+ r = KErrNoMemory;
+ goto F1;
+ }
+
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::SetInterface num_endpoints=%d", num_endpoints));
+
+ // other endpoints
+ // calculate the total buffer size
+ for (TInt i = 1; i <= num_endpoints; i++, pEndpointData++)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("SetInterface for ep=%d", i));
+ if (!ValidateEndpoint(pEndpointData))
+ {
+ r = KErrUsbBadEndpoint;
+ goto F2;
+ }
+
+ TUsbcEndpoint* ep = new TUsbcEndpoint(this, iController, pEndpointData, i, bandwidthPriority);
+ alternateSettingListRec->iEndpoint[i] = ep;
+ if (!ep)
+ {
+ r = KErrNoMemory;
+ goto F2;
+ }
+ if (ep->Construct() != KErrNone)
+ {
+ r = KErrNoMemory;
+ goto F2;
+ }
+
+ __KTRACE_OPT(KUSB, Kern::Printf("SetInterface for ep=%d rec=0x%08x ep==0x%08x",
+ i, alternateSettingListRec, ep));
+ }
+
+ // buf size of each endpoint
+ TInt bufSizes[KMaxEndpointsPerClient + 1];
+ TInt epNum[KMaxEndpointsPerClient + 1];
+
+ // init
+ for( TInt i=0;i<KMaxEndpointsPerClient+1;i++ )
+ {
+ bufSizes[i] = -1;
+ epNum[i] = i;
+ }
+
+ // Record the actual buf size of each endpoint
+ for( TInt i=1;i<=num_endpoints;i++ )
+ {
+ bufSizes[i] = alternateSettingListRec->iEndpoint[i]->BufferSize();
+ }
+
+ __KTRACE_OPT(KUSB, Kern::Printf("Sort the endpoints:"));
+
+ // sort the endpoint number by the bufsize decreasely
+ for( TInt i=1;i<num_endpoints;i++ )
+ {
+ TInt epMaxBuf = i;
+ for(TInt k=i+1;k<=num_endpoints;k++ )
+ {
+ if( bufSizes[epMaxBuf]<bufSizes[k])
+ {
+ epMaxBuf = k;
+ }
+ }
+ TInt temp = bufSizes[i];
+ bufSizes[i] = bufSizes[epMaxBuf];
+ bufSizes[epMaxBuf] = temp;
+
+ temp = epNum[i];
+ epNum[i] = epNum[epMaxBuf];
+ epNum[epMaxBuf] = temp;
+
+ alternateSettingListRec->iEpNumDeOrderedByBufSize[i] = epNum[i];
+
+ __KTRACE_OPT(KUSB, Kern::Printf(" %d:%d", epNum[i], bufSizes[i]));
+ }
+ alternateSettingListRec->iEpNumDeOrderedByBufSize[num_endpoints] = epNum[num_endpoints];
+ __KTRACE_OPT(KUSB, Kern::Printf(" %d:%d", epNum[num_endpoints], bufSizes[num_endpoints]));
+ __KTRACE_OPT(KUSB, Kern::Printf("\n"));
+
+ // chain in this alternate setting
+ alternateSettingListRec->iNext = iAlternateSettingList;
+ iAlternateSettingList = alternateSettingListRec;
+ alternateSettingListRec->iSetting = aInterfaceNumber;
+ alternateSettingListRec->iNumberOfEndpoints = num_endpoints;
+
+ // Record the 'real' endpoint number used by the PDD in both the Ep and
+ // the Req callback:
+ for (TInt i = 1; i <= num_endpoints; i++)
+ {
+ alternateSettingListRec->iEndpoint[i]->SetRealEpNumber(real_ep_numbers[i]);
+ }
+
+ r = SetupInterfaceMemory(iHwChunks, cacheAttribs );
+ if( r==KErrNone )
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("SetInterface ready to exit"));
+
+ if (aInterfaceNumber == 0)
+ {
+ // make sure we're ready to go with the main interface
+ iValidInterface = ETrue;
+ __KTRACE_OPT(KUSB, Kern::Printf("SetInterface SelectAlternateSetting"));
+ SelectAlternateSetting(0);
+ }
+ return KErrNone;
+ }
+ else
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Destroying all interfaces"));
+ DestroyAllInterfaces();
+ DestroyEp0();
+ return r;
+ }
+
+ F2:
+ delete alternateSettingListRec;
+ //Fall through
+
+ F1:
+#if _DEBUG
+ TInt r1 = iController->ReleaseInterface(this, aInterfaceNumber);
+ __KTRACE_OPT(KUSB, Kern::Printf("Release Interface controller returned %d", r1));
+#else
+ (void) iController->ReleaseInterface(this, aInterfaceNumber);
+#endif
+ return r;
+ }
+
+// realloc the memory, and set the previous interfaces
+TInt DLddUsbcChannel::SetupInterfaceMemory(RArray<DPlatChunkHw*> &aHwChunks,
+ TUint32 aCacheAttribs )
+ {
+ TUsbcAlternateSettingList* asRec = iAlternateSettingList;
+
+ // if buffers has been changed
+ TBool chunkChanged = EFalse;
+ TInt numOfEp = asRec->iNumberOfEndpoints;
+
+ // 1, collect all bufs' sizes for the current interface
+ // to realloc all the chunks
+ __KTRACE_OPT(KUSB, Kern::Printf("Collect all buffer sizes:"));
+ RArray<TInt> bufSizes;
+ for(TInt i=1;i<=numOfEp;i++)
+ {
+ TInt nextEp = asRec->iEpNumDeOrderedByBufSize[i];
+ TInt epBufCount = asRec->iEndpoint[nextEp]->BufferNumber();
+ __KTRACE_OPT(KUSB, Kern::Printf(" ep %d, buf count %d", nextEp, epBufCount ));
+ for(TInt k=0;k<epBufCount;k++)
+ {
+ TInt epBufSize = asRec->iEndpoint[nextEp]->BufferSize();
+ TInt r = bufSizes.Append(epBufSize);
+ if(r!=KErrNone)
+ {
+ iController->DeRegisterClient(this);
+ bufSizes.Close();
+ return r;
+ }
+ __KTRACE_OPT(KUSB,Kern::Printf(" %d", epBufSize ));
+ }
+ __KTRACE_OPT(KUSB, Kern::Printf("\n"));
+
+ }
+
+ // 2, alloc the buffer decreasely, biggest-->smallest
+ // 2.1 check the existing chunks
+ TInt bufCount = bufSizes.Count();
+ __KTRACE_OPT(KUSB, Kern::Printf(" ep buf number needed %d", bufCount ));
+ __KTRACE_OPT(KUSB, Kern::Printf(" chunks available %d", aHwChunks.Count() ));
+
+ TInt chunkInd = 0;
+ while( (chunkInd<aHwChunks.Count())&& (chunkInd<bufCount))
+ {
+ TUint8* oldAddr = NULL;
+ oldAddr = reinterpret_cast<TUint8*>(aHwChunks[chunkInd]->LinearAddress());
+
+ DPlatChunkHw* chunk = ReAllocate(bufSizes[chunkInd], aHwChunks[chunkInd], aCacheAttribs);
+ if (chunk == NULL)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Failed to alloc chunks size %d!", bufSizes[chunkInd]));
+ // lost all interfaces:
+ // Tell Controller to release Interface and h/w resources associated with this
+ iController->DeRegisterClient(this);
+ bufSizes.Close();
+ return KErrNoMemory;
+ }
+ else
+ {
+ // Parcel out the memory between endpoints
+ TUint8* newAddr = reinterpret_cast<TUint8*>(chunk->LinearAddress());
+ __KTRACE_OPT(KUSB, Kern::Printf("SetupInterfaceMemory alloc new chunk=0x%x, size=%d", newAddr,bufSizes[chunkInd]));
+ // The check is important to avoid chunkChanged to be corrupted.
+ // This code change is to fix the problem that one chunk is used by multiple interfaces.
+ if(!chunkChanged)
+ {
+ chunkChanged = (newAddr != oldAddr);
+ }
+ aHwChunks[chunkInd] = chunk;
+ }
+ chunkInd++;
+ }
+
+ // 2.2 in case available chunks are not enough
+ while( chunkInd<bufCount)
+ {
+ DPlatChunkHw* chunk = NULL;
+ chunk = Allocate( bufSizes[chunkInd], aCacheAttribs);
+ if (chunk == NULL)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Failed to alloc chunk, size %d!", bufSizes[chunkInd]));
+ // lost all interfaces:
+ // Tell Controller to release Interface and h/w resources associated with this
+ iController->DeRegisterClient(this);
+ bufSizes.Close();
+ return KErrNoMemory;
+ }
+ else
+ {
+ // Parcel out the memory between endpoints
+ __KTRACE_OPT(KUSB, Kern::Printf("SetupInterfaceMemory alloc new chunk=0x%x, size=%d",
+ reinterpret_cast<TUint8*>(chunk->LinearAddress()), bufSizes[chunkInd]));
+ TInt r = aHwChunks.Append(chunk);
+ if(r!=KErrNone)
+ {
+ ClosePhysicalChunk(chunk);
+ iController->DeRegisterClient(this);
+ bufSizes.Close();
+ return r;
+ }
+ }
+ chunkInd++;
+ }
+
+ // 3, Set the the bufs of the interfaces
+
+ ReSetInterfaceMemory(asRec, aHwChunks);
+
+ if(chunkChanged)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("SetupInterfaceMemory readdressing."));
+ asRec = asRec->iNext;
+ while (asRec)
+ {
+ // Interfaces are not concurrent so they can all start at the same logical address
+ __KTRACE_OPT(KUSB, Kern::Printf("SetupInterfaceMemory readdressing setting=%d", asRec->iSetting));
+ ReSetInterfaceMemory(asRec, aHwChunks);
+ asRec = asRec->iNext;
+ }
+ }
+ return KErrNone;
+ }
+
+TInt DLddUsbcChannel::SetupEp0()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("SetupEp0 entry %x", this));
+ TInt ep0Size = iController->Ep0PacketSize();
+ TUsbcEndpointInfo ep0Info = TUsbcEndpointInfo(UsbShai::KUsbEpTypeControl, UsbShai::KUsbEpDirBidirect, ep0Size);
+ TUsbcEndpoint* ep0 = new TUsbcEndpoint(this, iController, &ep0Info, 0, 0);
+ if (ep0 == NULL)
+ {
+ return KErrNoMemory;
+ }
+ // In case we have to return early:
+ iEndpoint[0] = ep0;
+ TInt r = ep0->Construct();
+ if (r != KErrNone)
+ {
+ return KErrNoMemory;
+ }
+
+ TInt bufferNum = ep0->BufferNumber();
+ TInt bufferSize = ep0->BufferSize();
+ TUint32 cacheAttribs = EMapAttrSupRw | EMapAttrCachedMax;
+
+ for(TInt i=0;i<bufferNum;i++)
+ {
+ DPlatChunkHw* chunk = Allocate(bufferSize, cacheAttribs );
+ if(chunk==NULL)
+ {
+ return KErrNoMemory;
+ }
+ TInt r = iHwChunksEp0.Append(chunk);
+ if(r!=KErrNone)
+ {
+ ClosePhysicalChunk(chunk);
+ return r;
+ }
+ TUint8 * buf;
+ buf = (TUint8*) chunk->LinearAddress();
+ ep0->SetBufferAddr( i, buf);
+ __KTRACE_OPT(KUSB, Kern::Printf("SetupEp0 60 buffer number %d", i));
+ __KTRACE_OPT(KUSB, Kern::Printf("SetupEp0 60 buffer size %d", bufferSize));
+ }
+
+ ep0->SetRealEpNumber(0);
+ return KErrNone;
+ }
+
+// Set buffer address of the interface
+// Precondition: Enough chunks available.
+void DLddUsbcChannel::ReSetInterfaceMemory(TUsbcAlternateSettingList* aAlternateSettingListRec,
+ RArray<DPlatChunkHw*> &aHwChunks)
+ {
+ TUsbcAlternateSettingList* asRec = aAlternateSettingListRec;
+
+ // set all the interfaces
+ TInt chunkInd = 0;
+ TInt numOfEp = asRec->iNumberOfEndpoints;
+
+ for (TInt i = 1; i <= numOfEp; i++)
+ {
+ TInt nextEp = asRec->iEpNumDeOrderedByBufSize[i];
+ TInt epBufCount = asRec->iEndpoint[nextEp]->BufferNumber();
+ for(TInt k=0;k<epBufCount;k++)
+ {
+ TUsbcEndpoint* ep = asRec->iEndpoint[nextEp];
+ if (ep != NULL )
+ {
+ TUint8* pBuf = NULL;
+ pBuf = reinterpret_cast<TUint8*>(aHwChunks[chunkInd]->LinearAddress());
+ ep->SetBufferAddr( k, pBuf);
+ __KTRACE_OPT(KUSB, Kern::Printf(" ep %d, buf %d, addr 0x%x", nextEp, k, pBuf ));
+ chunkInd++;
+ __ASSERT_DEBUG(chunkInd<=aHwChunks.Count(),
+ Kern::Printf(" Error: available chunks %d, run out at epInd%d, bufInd%d",
+ aHwChunks.Count(), i, k));
+ __ASSERT_DEBUG(chunkInd<=aHwChunks.Count(),
+ Kern::Fault("usbc.ldd", __LINE__));
+ }
+ }
+ }
+
+ }
+
+void DLddUsbcChannel::DestroyAllInterfaces()
+ {
+ // Removes all interfaces
+ TUsbcAlternateSettingList* alternateSettingListRec = iAlternateSettingList;
+ while (alternateSettingListRec)
+ {
+ iController->ReleaseInterface(this, alternateSettingListRec->iSetting);
+ TUsbcAlternateSettingList* alternateSettingListRecNext = alternateSettingListRec->iNext;
+ delete alternateSettingListRec;
+ alternateSettingListRec = alternateSettingListRecNext;
+ }
+ iNumberOfEndpoints = 0;
+ iAlternateSettingList = NULL;
+
+ for(TInt i=0;i<iHwChunks.Count();i++)
+ {
+ ClosePhysicalChunk( iHwChunks[i]);
+ }
+ iHwChunks.Close();
+
+ iValidInterface = EFalse;
+ }
+
+
+void DLddUsbcChannel::DestroyInterface(TUint aInterfaceNumber)
+ {
+ if (iAlternateSetting == aInterfaceNumber)
+ {
+ ResetInterface(KErrUsbInterfaceNotReady);
+ iValidInterface = EFalse;
+ iNumberOfEndpoints = 0;
+ for (TInt i = 1; i <= KMaxEndpointsPerClient; i++)
+ {
+ iEndpoint[i] = NULL;
+ }
+ }
+ TUsbcAlternateSettingList* alternateSettingListRec = iAlternateSettingList;
+ TUsbcAlternateSettingList* alternateSettingListRecOld = NULL;
+ while (alternateSettingListRec)
+ {
+ TUsbcAlternateSettingList* alternateSettingListRecNext = alternateSettingListRec->iNext;
+ if (alternateSettingListRec->iSetting == aInterfaceNumber)
+ {
+ // This record is to be deleted
+ if (alternateSettingListRecOld == NULL)
+ {
+ // The record to be deleted is at the list head
+ iAlternateSettingList = alternateSettingListRecNext;
+ }
+ else
+ {
+ // The record to be deleted is NOT at the list head
+ alternateSettingListRecOld->iNext = alternateSettingListRecNext;
+ }
+ delete alternateSettingListRec;
+ break;
+ }
+ alternateSettingListRecOld = alternateSettingListRec;
+ alternateSettingListRec = alternateSettingListRecNext;
+ }
+
+ if (iAlternateSettingList == NULL)
+ {
+ // if no interfaces left destroy non-ep0 buffering
+ for(TInt i=0;i<iHwChunks.Count();i++)
+ {
+ ClosePhysicalChunk( iHwChunks[i]);
+ }
+ iHwChunks.Close();
+ }
+ }
+
+
+void DLddUsbcChannel::DestroyEp0()
+ {
+ delete iEndpoint[0];
+ iEndpoint[0] = NULL;
+ for(TInt i=0;i<iHwChunksEp0.Count();i++)
+ {
+ ClosePhysicalChunk( iHwChunksEp0[i] );
+ }
+ iHwChunksEp0.Close();
+ }
+
+
+void DLddUsbcChannel::EndpointStatusChangeCallback(TAny* aDLddUsbcChannel)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("EndpointStatusChangeCallback"));
+ DLddUsbcChannel* dUsbc = (DLddUsbcChannel*) aDLddUsbcChannel;
+ if (dUsbc->iChannelClosing)
+ return;
+ TUint endpointState = dUsbc->iEndpointStatusCallbackInfo.State();
+ const TInt reqNo = (TInt) RDevUsbcClient::ERequestEndpointStatusNotify;
+ if (dUsbc->iRequestStatus[reqNo])
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("EndpointStatusChangeCallback Notify status"));
+ DThread* client = dUsbc->iClient;
+
+ dUsbc->iEndpointStatusChangeReq->Data() = endpointState;
+ dUsbc->iRequestStatus[reqNo] = NULL;
+ Kern::QueueRequestComplete(client,dUsbc->iEndpointStatusChangeReq,KErrNone);
+ dUsbc->iEndpointStatusChangePtr = NULL;
+ }
+ }
+
+
+void DLddUsbcChannel::StatusChangeCallback(TAny* aDLddUsbcChannel)
+ {
+ DLddUsbcChannel* dUsbc = (DLddUsbcChannel*) aDLddUsbcChannel;
+ if (dUsbc->iChannelClosing)
+ return;
+
+ TUsbcDeviceState deviceState;
+ TInt i;
+ for (i = 0;
+ (i < KUsbcDeviceStateRequests) && ((deviceState = dUsbc->iStatusCallbackInfo.State(i)) != UsbShai::EUsbPeripheralNoState);
+ ++i)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("StatusChangeCallBack status=%d", deviceState));
+ if (deviceState & KUsbAlternateSetting)
+ {
+ dUsbc->ProcessAlternateSetting(deviceState);
+ }
+ else
+ {
+ dUsbc->ProcessDeviceState(deviceState);
+ }
+ // Only queue if userside is interested
+ if (dUsbc->iDeviceStatusNeeded)
+ {
+ dUsbc->iStatusFifo->AddStatusToQueue(deviceState);
+ const TInt reqNo = (TInt) RDevUsbcClient::ERequestAlternateDeviceStatusNotify;
+ if (dUsbc->AlternateDeviceStateTestComplete())
+ {
+ dUsbc->iRequestStatus[reqNo]=NULL;
+ Kern::QueueRequestComplete(dUsbc->iClient,dUsbc->iStatusChangeReq,KErrNone);
+ }
+ }
+ }
+ // We don't want to be interrupted in the middle of this:
+ const TInt irqs = NKern::DisableInterrupts(2);
+ dUsbc->iStatusCallbackInfo.ResetState();
+ NKern::RestoreInterrupts(irqs);
+ }
+
+
+void DLddUsbcChannel::OtgFeatureChangeCallback(TAny* aDLddUsbcChannel)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("OtgFeatureChangeCallback"));
+ DLddUsbcChannel* dUsbc = (DLddUsbcChannel*) aDLddUsbcChannel;
+ if (dUsbc->iChannelClosing)
+ return;
+
+ TUint8 features;
+ // No return value check. Assume OTG always supported here
+ dUsbc->iController->GetCurrentOtgFeatures(features);
+
+ const TInt reqNo = (TInt) RDevUsbcClient::ERequestOtgFeaturesNotify;
+ if (dUsbc->iRequestStatus[reqNo])
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("OtgFeatureChangeCallback Notify status"));
+ dUsbc->iOtgFeatureChangeReq->Data()=features;
+ dUsbc->iRequestStatus[reqNo] = NULL;
+ Kern::QueueRequestComplete(dUsbc->iClient,dUsbc->iOtgFeatureChangeReq,KErrNone);
+ dUsbc->iOtgFeatureChangePtr = NULL;
+ }
+ }
+
+
+TInt DLddUsbcChannel::SelectAlternateSetting(TUint aAlternateSetting)
+ {
+ TInt r = KErrGeneral; // error code doesn't go userside
+ TUsbcAlternateSettingList* alternateSettingListRec = iAlternateSettingList;
+ while (alternateSettingListRec)
+ {
+ if (alternateSettingListRec->iSetting == aAlternateSetting)
+ {
+ // found the correct interface, now latch in new endpoint set
+ for (TInt i = 1; i <= KMaxEndpointsPerClient; i++)
+ {
+ iEndpoint[i] = NULL;
+ }
+ iNumberOfEndpoints = alternateSettingListRec->iNumberOfEndpoints;
+ r = KErrNone;
+ for (TInt i = 1; i <= KMaxEndpointsPerClient; i++)
+ {
+ iEndpoint[i] = alternateSettingListRec->iEndpoint[i];
+ }
+ // Only after correct alternate setting has been chosen.
+ UpdateEndpointSizes();
+ }
+ alternateSettingListRec = alternateSettingListRec->iNext;
+ }
+ return r;
+ }
+
+
+TInt DLddUsbcChannel::EpFromAlternateSetting(TUint aAlternateSetting, TInt aEndpoint)
+ {
+ TUsbcAlternateSettingList* alternateSettingListRec = iAlternateSettingList;
+ while (alternateSettingListRec)
+ {
+ if (alternateSettingListRec->iSetting == aAlternateSetting)
+ {
+ if ((aEndpoint <= alternateSettingListRec->iNumberOfEndpoints) &&
+ (aEndpoint >= 0))
+ {
+ return alternateSettingListRec->iEndpoint[aEndpoint]->RealEpNumber();
+ }
+ else
+ {
+ __KTRACE_OPT(KPANIC, Kern::Printf(" Error: aEndpoint %d wrong for aAlternateSetting %d",
+ aEndpoint, aAlternateSetting));
+ return -1;
+ }
+ }
+ alternateSettingListRec = alternateSettingListRec->iNext;
+ }
+ __KTRACE_OPT(KPANIC, Kern::Printf(" Error: no aAlternateSetting %d found", aAlternateSetting));
+ return -1;
+ }
+
+
+TInt DLddUsbcChannel::ProcessAlternateSetting(TUint aAlternateSetting)
+ {
+ ResetInterface(KErrUsbInterfaceChange); // kill any outstanding transfers
+ __KTRACE_OPT(KUSB, Kern::Printf("ProcessAlternateSetting 0x%08x", aAlternateSetting));
+ TUint newSetting = aAlternateSetting&(~KUsbAlternateSetting);
+ __KTRACE_OPT(KUSB, Kern::Printf("ProcessAlternateSetting selecting alternate setting 0x%08x", newSetting));
+ TInt r = SelectAlternateSetting(newSetting);
+ if (r != KErrNone)
+ return r;
+ StartEpReads();
+ iAlternateSetting = newSetting;
+ return KErrNone;
+ }
+
+
+TInt DLddUsbcChannel::ProcessDeviceState(TUsbcDeviceState aDeviceState)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("ProcessDeviceState(%d -> %d)", iDeviceState, aDeviceState));
+ if (iDeviceState == aDeviceState)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" No state change => nothing to be done."));
+ return KErrNone;
+ }
+ if (iDeviceState == UsbShai::EUsbPeripheralStateSuspended)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" Coming out of Suspend: old state = %d", iOldDeviceState));
+ iDeviceState = iOldDeviceState;
+ if (iDeviceState == aDeviceState)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" New state same as before Suspend => nothing to be done."));
+ return KErrNone;
+ }
+ }
+ TBool renumerateState = (aDeviceState == UsbShai::EUsbPeripheralStateConfigured);
+ TBool deconfigured = EFalse;
+ TInt cancellationCode = KErrNone;
+ if (aDeviceState == UsbShai::EUsbPeripheralStateSuspended)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" Suspending..."));
+ iOldDeviceState = iDeviceState;
+ // Put PSL into low power mode here
+ }
+ else
+ {
+ deconfigured = (iDeviceState == UsbShai::EUsbPeripheralStateConfigured &&
+ aDeviceState != UsbShai::EUsbPeripheralStateConfigured);
+ if (iDeviceState == UsbShai::EUsbPeripheralStateConfigured)
+ {
+ if (aDeviceState == UsbShai::EUsbPeripheralStateUndefined)
+ cancellationCode = KErrUsbCableDetached;
+ else if (aDeviceState == UsbShai::EUsbPeripheralStateAddress)
+ cancellationCode = KErrUsbDeviceNotConfigured;
+ else if (aDeviceState == UsbShai::EUsbPeripheralStateDefault)
+ cancellationCode = KErrUsbDeviceBusReset;
+ else
+ cancellationCode = KErrUsbDeviceNotConfigured;
+ }
+ }
+ __KTRACE_OPT(KUSB, Kern::Printf(" %d --> %d", iDeviceState, aDeviceState));
+ iDeviceState = aDeviceState;
+ if (iValidInterface || iOwnsDeviceControl)
+ {
+ // This LDD may not own an interface. It could be some manager reenumerating
+ // after its subordinate LDDs have setup their interfaces.
+ if (deconfigured)
+ {
+ DeConfigure(cancellationCode);
+ }
+ else if (renumerateState)
+ {
+ // Update size of Ep0.
+ iEndpoint[0]->SetMaxPacketSize(iController->Ep0PacketSize());
+ // First cancel transfers on all endpoints
+ ResetInterface(KErrUsbInterfaceChange);
+ // Select main interface & latch in new endpoint set
+ SelectAlternateSetting(0);
+ // Here we go
+ StartEpReads();
+ }
+ }
+
+ const TInt reqNo = (TInt) RDevUsbcClient::ERequestReEnumerate;
+ if (renumerateState && iRequestStatus[reqNo])
+ {
+ // This lot must be done if we are reenumerated
+ CompleteBufferRequest(iClient, reqNo, KErrNone);
+ }
+
+ return KErrNone;
+ }
+
+
+void DLddUsbcChannel::UpdateEndpointSizes()
+ {
+ // The regular ones.
+ TInt i = 0;
+ while ((++i <= KMaxEndpointsPerClient) && iEndpoint[i])
+ {
+ const TInt size = iController->EndpointPacketSize(this, iEndpoint[i]->RealEpNumber());
+ if (size < 0)
+ {
+ __KTRACE_OPT(KPANIC, Kern::Printf(" Error: Packet size < 0 for ep %d", i));
+ continue;
+ }
+ iEndpoint[i]->SetMaxPacketSize(size);
+ }
+ __ASSERT_DEBUG(i == iNumberOfEndpoints + 1,
+ Kern::Printf(" Error: iNumberOfEndpoints wrong (%d)", iNumberOfEndpoints));
+ }
+
+
+DPlatChunkHw* DLddUsbcChannel::ReAllocate(TInt aBuffersize, DPlatChunkHw* aHwChunk, TUint32 aCacheAttribs)
+ {
+ DPlatChunkHw* chunk = aHwChunk;
+ if ((!chunk) || (chunk->iSize < aBuffersize))
+ {
+ if (chunk)
+ {
+ ClosePhysicalChunk(chunk);
+ }
+ __KTRACE_OPT(KUSB, Kern::Printf("ReAllocate need to get new chunk"));
+ chunk = Allocate(aBuffersize, aCacheAttribs);
+ }
+ return chunk;
+ }
+
+
+DPlatChunkHw* DLddUsbcChannel::Allocate(TInt aBuffersize, TUint32 aCacheAttribs)
+ {
+ TUint32 physAddr = 0;
+ TUint32 size = Kern::RoundToPageSize(aBuffersize);
+
+ if (Epoc::AllocPhysicalRam(size, physAddr) != KErrNone)
+ return NULL;
+
+ DPlatChunkHw* HwChunk;
+ if (DPlatChunkHw::New(HwChunk, physAddr, aBuffersize, aCacheAttribs) != KErrNone)
+ {
+ Epoc::FreePhysicalRam(physAddr, size);
+ return NULL;
+ }
+
+ return HwChunk;
+ }
+
+
+TInt DLddUsbcChannel::DoRxComplete(TUsbcEndpoint* aTUsbcEndpoint, TInt aEndpoint, TBool aReEntrant)
+ {
+ TBool completeNow;
+ TInt err = aTUsbcEndpoint->CopyToClient(iClient, completeNow,iClientAsynchNotify[aEndpoint]->iClientBuffer);
+ if (completeNow)
+ {
+ aTUsbcEndpoint->SetClientReadPending(EFalse);
+ CompleteBufferRequest(iClient, aEndpoint, err);
+ }
+ aTUsbcEndpoint->TryToStartRead(aReEntrant);
+ return err;
+ }
+
+
+void DLddUsbcChannel::DoRxCompleteNow(TUsbcEndpoint* aTUsbcEndpoint, TInt aEndpoint)
+ {
+ aTUsbcEndpoint->SetClientReadPending(EFalse);
+ CompleteBufferRequest(iClient, aEndpoint, KErrCancel);
+ }
+
+
+void DLddUsbcChannel::DoTxComplete(TUsbcEndpoint* aTUsbcEndpoint, TInt aEndpoint, TInt aError)
+ {
+ aTUsbcEndpoint->SetClientWritePending(EFalse);
+ CompleteBufferRequest(iClient, aEndpoint, aError);
+ }
+
+
+TBool DLddUsbcChannel::AlternateDeviceStateTestComplete()
+ {
+ TBool completeNow = EFalse;
+ const TInt reqNo = (TInt) RDevUsbcClient::ERequestAlternateDeviceStatusNotify;
+ if (iRequestStatus[reqNo])
+ {
+ // User req is outstanding
+ TUint32 deviceState;
+ if (iStatusFifo->GetDeviceQueuedStatus(deviceState) == KErrNone)
+ {
+ // Device state waiting to be sent userside
+ completeNow = ETrue;
+ __KTRACE_OPT(KUSB, Kern::Printf("StatusChangeCallback Notify status"));
+ iStatusChangeReq->Data()=deviceState;
+ iStatusChangePtr = NULL;
+ }
+ }
+ return completeNow;
+ }
+
+
+void DLddUsbcChannel::EmergencyCompleteDfc(TAny* aDLddUsbcChannel)
+ {
+ ((DLddUsbcChannel*) aDLddUsbcChannel)->DoEmergencyComplete();
+ }
+
+
+void DLddUsbcChannel::DeConfigure(TInt aErrorCode)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::DeConfigure()"));
+ // Called after deconfiguration. Cancels transfers on all endpoints.
+ ResetInterface(aErrorCode);
+ // Cancel the endpoint status notify request if it is outstanding.
+ const TInt KEpNotReq = RDevUsbcClient::ERequestEndpointStatusNotify;
+ if (iRequestStatus[KEpNotReq])
+ {
+ CancelNotifyEndpointStatus();
+ iRequestStatus[KEpNotReq]=NULL;
+ Kern::QueueRequestComplete(iClient,iEndpointStatusChangeReq,aErrorCode);
+ }
+ // We have to reset the alternate setting number when the config goes away.
+ SelectAlternateSetting(0);
+ iAlternateSetting = 0;
+ }
+
+
+void DLddUsbcChannel::StartEpReads()
+ {
+ // Queued after enumeration. Starts reads on all endpoints.
+ // The endpoint itself decides if it can do a read
+ TInt i;
+ for (i = 0; i <= iNumberOfEndpoints; i++)
+ {
+ // The endpoint itself will decide if it can read
+ iEndpoint[i]->TryToStartRead(EFalse);
+ }
+ }
+
+
+void DLddUsbcChannel::ResetInterface(TInt aErrorCode)
+ {
+ // Called after change in alternate setting. Cancels transfers on all endpoints
+ if (iValidInterface || iOwnsDeviceControl)
+ {
+ // Reset each endpoint except ep0
+ for (TInt i = 1; i <= iNumberOfEndpoints; i++)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Cancelling transfer ep=%d", i));
+ iEndpoint[i]->CancelTransfer(iClient,iClientAsynchNotify[i]->iClientBuffer); // Copies data userside
+ iEndpoint[i]->AbortTransfer(); // kills any ldd->pil outstanding transfers
+ iEndpoint[i]->iDmaBuffers->Flush();
+ if (iRequestStatus[i] != NULL)
+ CompleteBufferRequest(iClient, i, aErrorCode);
+ iEndpoint[i]->SetClientWritePending(EFalse);
+ iEndpoint[i]->SetClientReadPending(EFalse);
+ }
+ }
+ }
+
+
+void DLddUsbcChannel::AbortInterface()
+ {
+ // Called after when channel is closing
+ if (iValidInterface || iOwnsDeviceControl)
+ {
+ for (TInt i = 0; i <= iNumberOfEndpoints; i++)
+ {
+ if (iEndpoint[i])
+ {
+ // kills any LDD->PDD outstanding transfers
+ iEndpoint[i]->AbortTransfer();
+ }
+ }
+ }
+ }
+
+
+void DLddUsbcChannel::ClosePhysicalChunk(DPlatChunkHw*& aHwChunk)
+ {
+ if (aHwChunk)
+ {
+ const TPhysAddr addr = aHwChunk->PhysicalAddress();
+ const TInt size = aHwChunk->iSize;
+ aHwChunk->Close(NULL);
+ Epoc::FreePhysicalRam(addr, size);
+ }
+ aHwChunk = NULL;
+ }
+
+
+TInt DLddUsbcChannel::DoEmergencyComplete()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::DoEmergencyComplete"));
+ // cancel any pending DFCs
+ // complete all client requests
+ for (TInt i = 0; i < KUsbcMaxRequests; i++)
+ {
+ if (iRequestStatus[i])
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Complete request 0x%x", iRequestStatus[i]));
+
+ if (i == RDevUsbcClient::ERequestAlternateDeviceStatusNotify)
+ {
+
+ iDeviceStatusNeeded = EFalse;
+ iStatusFifo->FlushQueue();
+
+ if (iStatusChangePtr)
+ {
+ iStatusChangeReq->Data() = iController->GetDeviceStatus();
+ iStatusChangePtr = NULL;
+
+ if (iStatusChangeReq->IsReady())
+ {
+ iRequestStatus[i] = NULL;
+ Kern::QueueRequestComplete(iClient, iStatusChangeReq,
+ KErrDisconnected);
+ }
+ }
+
+ }
+ else if (i == RDevUsbcClient::ERequestEndpointStatusNotify)
+ {
+
+ if (iEndpointStatusChangePtr)
+ {
+ TUint epBitmap = 0;
+ for (TInt i = 0; i <= iNumberOfEndpoints; i++)
+ {
+ TInt v = iController->GetEndpointStatus(this, iEndpoint[i]->RealEpNumber());
+ TUint b;
+ (v == EEndpointStateStalled) ? b = 1 : b = 0;
+ epBitmap |= b << i;
+ }
+
+ iEndpointStatusChangeReq->Data() = epBitmap;
+ iEndpointStatusChangePtr = NULL;
+ }
+
+ if (iEndpointStatusChangeReq->IsReady())
+ {
+ iRequestStatus[i] = NULL;
+ Kern::QueueRequestComplete(iClient,iEndpointStatusChangeReq,KErrDisconnected);
+ }
+
+ }
+ else if (i == RDevUsbcClient::ERequestOtgFeaturesNotify)
+ {
+
+ if (iOtgFeatureChangePtr)
+ {
+ TUint8 features;
+ iController->GetCurrentOtgFeatures(features);
+ iOtgFeatureChangeReq->Data()=features;
+ iOtgFeatureChangePtr = NULL;
+ }
+
+ if (iOtgFeatureChangeReq->IsReady())
+ {
+ iRequestStatus[i] = NULL;
+ Kern::QueueRequestComplete(iClient, iOtgFeatureChangeReq,
+ KErrDisconnected);
+ }
+
+ }
+ else
+ {
+ CompleteBufferRequest(iClient, i, KErrDisconnected);
+ }
+
+ }
+ }
+
+ iStatusCallbackInfo.Cancel();
+ iEndpointStatusCallbackInfo.Cancel();
+ iOtgFeatureCallbackInfo.Cancel();
+ return KErrNone;
+ }
+
+
+void DLddUsbcChannel::PanicClientThread(TInt aReason)
+ {
+ Kern::ThreadKill(iClient, EExitPanic, aReason, KUsbLDDKillCat);
+ }
+
+
+// ===============Endpoint====================
+
+// Constructor
+TUsbcEndpoint::TUsbcEndpoint(DLddUsbcChannel* aLDD, DUsbClientController* aController,
+ const TUsbcEndpointInfo* aEndpointInfo, TInt aEndpointNum,
+ TInt aBandwidthPriority)
+ : iController(aController),
+ iEndpointInfo(aEndpointInfo->iType, aEndpointInfo->iDir, aEndpointInfo->iSize),
+ iClientReadPending(EFalse),
+ iClientWritePending(EFalse),
+ iEndpointNumber(aEndpointNum),
+ iRealEpNumber(-1),
+ iLdd(aLDD),
+ iError(KErrNone),
+ iRequestCallbackInfo(NULL),
+ iBytesTransferred(0),
+ iBandwidthPriority(aBandwidthPriority)
+ {
+ ResetTransferInfo();
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::TUsbcEndpoint 2"));
+ }
+
+
+TInt TUsbcEndpoint::Construct()
+ {
+ iDmaBuffers = new TDmaBuf(&iEndpointInfo, iBandwidthPriority);
+ if (iDmaBuffers == NULL)
+ {
+ return KErrNoMemory;
+ }
+ const TInt r = iDmaBuffers->Construct(&iEndpointInfo);
+ if (r != KErrNone)
+ {
+ return r;
+ }
+ iRequestCallbackInfo = new TUsbcRequestCallback(iLdd,
+ iEndpointNumber,
+ TUsbcEndpoint::RequestCallback,
+ this,
+ iLdd->iDfcQ,
+ KUsbRequestCallbackPriority);
+ if (iRequestCallbackInfo == NULL)
+ {
+ return KErrNoMemory;
+ }
+ return KErrNone;
+ }
+
+
+TUsbcEndpoint::~TUsbcEndpoint()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::~TUsbcEndpoint(%d)", iEndpointNumber));
+ AbortTransfer();
+ delete iRequestCallbackInfo;
+ delete iDmaBuffers;
+ }
+
+
+void TUsbcEndpoint::RequestCallback(TAny* aTUsbcEndpoint)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::RequestCallback"));
+ ((TUsbcEndpoint*) aTUsbcEndpoint)->EndpointComplete();
+ }
+
+
+void TUsbcEndpoint::SetMaxPacketSize(TInt aSize)
+ {
+ iEndpointInfo.iSize = aSize;
+ iDmaBuffers->SetMaxPacketSize(aSize);
+ }
+
+
+TInt TUsbcEndpoint::EndpointComplete()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::EndpointComplete ep=%d %d",
+ iEndpointNumber, iRequestCallbackInfo->iEndpointNum));
+
+ if (iLdd->ChannelClosing())
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("We're going home -> completions no longer accepted"));
+ return KErrNone;
+ }
+
+ UsbShai::TTransferDirection transferDir = iRequestCallbackInfo->iTransferDir;
+ TInt error = iRequestCallbackInfo->iError;
+
+ switch (transferDir)
+ {
+
+ case UsbShai::EControllerWrite:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::EndpointComplete Write 2"));
+ if (!iDmaBuffers->TxIsActive())
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" TX completion but !iDmaBuffers->TxIsActive()"));
+ break;
+ }
+
+ iDmaBuffers->TxSetInActive();
+ TBool completeNow = EFalse;
+ iBytesTransferred += iRequestCallbackInfo->iTxBytes;
+ if (iClientWritePending)
+ {
+ //Complete Outstanding Write if necessary
+ iError = error;
+ if (iError != KErrNone)
+ {
+ completeNow = ETrue;
+ if (iError == KErrPrematureEnd) // Previous write could not be completed
+ iError = KErrNone;
+ }
+ else
+ {
+ if (iBytesTransferred == (TUint32) iTransferInfo.iTransferSize)
+ {
+ completeNow = ETrue;
+ }
+ else
+ {
+ iError = ContinueWrite();
+ if (iError != KErrNone)
+ completeNow = ETrue;
+ }
+ }
+ if (completeNow)
+ {
+ TxComplete();
+ ResetTransferInfo();
+ if (iEndpointNumber == 0)
+ {
+ iDmaBuffers->Flush();
+ TryToStartRead(EFalse);
+ }
+ }
+ }
+ break;
+ }
+
+ case UsbShai::EControllerRead:
+ {
+ // The first packet always contains the total #of bytes
+ const TInt byteCount = iRequestCallbackInfo->iPacketSize[0];
+ const TInt packetCount = iRequestCallbackInfo->iRxPackets;
+ iDmaBuffers->ReadXferComplete(byteCount, packetCount, error);
+
+ // We queue the dfc if we can complete the read, i.e. if we are reading a packet,
+ // or if we have enough data to satisfy a read data request.
+ if (iClientReadPending)
+ {
+ //Complete outstanding read
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::EndpointComplete Read 3 (bytes "
+ "available=%d)", iDmaBuffers->RxBytesAvailable()));
+ TInt bytesReqd = iTransferInfo.iTransferSize - iBytesTransferred;
+ TBool completeNow = EFalse;
+
+ if (iTransferInfo.iTransferType == ETransferTypeReadPacket ||
+ iTransferInfo.iTransferType == ETransferTypeReadOneOrMore)
+ {
+ // Always complete on a packet read
+ completeNow = ETrue;
+ }
+ else if (iTransferInfo.iTransferType == ETransferTypeReadData)
+ {
+ // Complete only if enough data is present
+ if (iDmaBuffers->RxBytesAvailable() >= bytesReqd)
+ completeNow = ETrue;
+ }
+ else if (iTransferInfo.iTransferType == ETransferTypeReadUntilShort)
+ {
+ // Complete if enough data is present or if a short packet has been delivered
+ const TInt maxPacketSize = iEndpointInfo.iSize;
+ const TInt lastPacketSize = iRequestCallbackInfo->iPacketSize[packetCount - 1];
+ if (lastPacketSize < maxPacketSize)
+ completeNow = ETrue;
+ else if (iDmaBuffers->RxBytesAvailable() >= bytesReqd)
+ completeNow = ETrue;
+ else
+ {
+ const TUint type = iEndpointInfo.iType;
+ if ((type == UsbShai::KUsbEpTypeBulk) && (lastPacketSize & (maxPacketSize - 1)))
+ {
+ completeNow = ETrue;
+ }
+ else if ((type != UsbShai::KUsbEpTypeBulk) &&
+ (lastPacketSize > maxPacketSize) &&
+ (lastPacketSize % maxPacketSize))
+ {
+ completeNow = ETrue;
+ }
+ }
+ }
+ if (completeNow)
+ {
+ iError = error;
+ RxComplete(EFalse);
+ iClientReadPending = EFalse;
+ }
+ }
+ iDmaBuffers->RxSetInActive();
+ if (error != KErrNone)
+ {
+ return error;
+ }
+ if (TryToStartRead(EFalse) != KErrNone)
+ {
+// if (iEndpointNumber != 0)
+// Kern::Printf("EndpointComplete couldn't start read on ep=%d", iEndpointNumber);
+ }
+ break;
+ }
+
+ default:
+ // shouldn't get here
+ break;
+ }
+
+ return KErrNone;
+ }
+
+
+void TUsbcEndpoint::TxComplete()
+ {
+ iLdd->DoTxComplete(this, iEndpointNumber, iError);
+ }
+
+
+TInt TUsbcEndpoint::RxComplete(TBool aReEntrant)
+ {
+ return iLdd->DoRxComplete(this, iEndpointNumber, aReEntrant);
+ }
+
+
+void TUsbcEndpoint::RxCompleteNow()
+ {
+ iLdd->DoRxCompleteNow(this, iEndpointNumber);
+ }
+
+
+TInt TUsbcEndpoint::CopyToClient(DThread* aClient, TClientBuffer *aTcb)
+ {
+ TBool completeNow;
+ return CopyToClient(aClient, completeNow,aTcb);
+ }
+
+
+TInt TUsbcEndpoint::CopyToClient(DThread* aClient, TBool& aCompleteNow, TClientBuffer *aTcb)
+ {
+ TInt err;
+ const TInt length = iTransferInfo.iTransferSize;
+ const TBool KReadData = EFalse;
+ const TBool KReadUntilShort = ETrue;
+
+ __KTRACE_OPT(KUSB, Kern::Printf("CopyToClient: length = %d", length));
+
+ if (iTransferInfo.iTransferType == ETransferTypeReadPacket)
+ {
+ err = iDmaBuffers->RxCopyPacketToClient(aClient, aTcb, length);
+ aCompleteNow = ETrue;
+ }
+ else if (iTransferInfo.iTransferType == ETransferTypeReadOneOrMore)
+ {
+ err = iDmaBuffers->RxCopyDataToClient(aClient, aTcb, length, iBytesTransferred,
+ KReadData, aCompleteNow);
+ aCompleteNow = ETrue;
+ }
+ else if (iTransferInfo.iTransferType == ETransferTypeReadUntilShort)
+ {
+ err = iDmaBuffers->RxCopyDataToClient(aClient, aTcb, length, iBytesTransferred,
+ KReadUntilShort, aCompleteNow);
+ }
+ else
+ {
+ err = iDmaBuffers->RxCopyDataToClient(aClient, aTcb, length, iBytesTransferred,
+ KReadData, aCompleteNow);
+ }
+
+ if (aCompleteNow)
+ {
+ ResetTransferInfo();
+ SetClientReadPending(EFalse);
+ }
+
+ return err;
+ }
+
+
+TInt TUsbcEndpoint::TryToStartRead(TBool aReEntrant)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TryToStartRead 1 ep=%d", iEndpointNumber));
+ TInt r = KErrNone;
+ if (iEndpointInfo.iDir != UsbShai::KUsbEpDirOut &&
+ iEndpointInfo.iDir != UsbShai::KUsbEpDirBidirect)
+ {
+ // Verify ep direction
+ __KTRACE_OPT(KUSB, Kern::Printf("TryToStartRead wrong direction ep=%d", iEndpointNumber));
+ return KErrUsbEpBadDirection;
+ }
+
+ if (iEndpointNumber == 0)
+ {
+ // Can't issue an Ep0 read if reader or writer is active
+ if (iDmaBuffers->TxIsActive())
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TryToStartRead ep0 Tx already active FATAL"));
+ return KErrUsbEpNotReady;
+ }
+ if (iDmaBuffers->RxIsActive())
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TryToStartRead ep0 Rx already active non-FATAL"));
+ }
+ }
+
+ if (!(iDmaBuffers->RxIsActive()))
+ {
+ TUint8* bufferAddr;
+ TPhysAddr physAddr;
+ TUsbcPacketArray* indexArray;
+ TUsbcPacketArray* sizeArray;
+ TInt length;
+ r = iDmaBuffers->RxGetNextXfer(bufferAddr, indexArray, sizeArray, length, physAddr);
+ if (r == KErrNone)
+ {
+ iDmaBuffers->RxSetActive();
+ iRequestCallbackInfo->SetRxBufferInfo(bufferAddr, physAddr, indexArray, sizeArray, length);
+
+ __KTRACE_OPT(KUSB, Kern::Printf("TryToStartRead 2 bufferAddr=0x%08x", bufferAddr));
+
+ r = iController->SetupReadBuffer(*iRequestCallbackInfo);
+ if (r != KErrNone)
+ {
+ iDmaBuffers->RxSetInActive();
+ __KTRACE_OPT(KPANIC, Kern::Printf(" Error: TryToStartRead controller rejects read"));
+ }
+ }
+ else
+ {
+ if (iClientReadPending)
+ {
+ // Deadlock, try to resolve it by draining buffer into descriptor
+ if (!aReEntrant)
+ {
+ RxComplete(ETrue);
+ }
+ else
+ {
+ // we are stuck, better complete userside otherwise the userside request will hang
+ RxCompleteNow();
+ }
+ }
+ }
+ }
+ return r;
+ }
+
+
+TInt TUsbcEndpoint::TryToStartWrite(TEndpointTransferInfo* pTfr)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TryToStartWrite 1 ep=%d", iEndpointNumber));
+ if (iEndpointInfo.iDir != UsbShai::KUsbEpDirIn &&
+ iEndpointInfo.iDir != UsbShai::KUsbEpDirBidirect)
+ {
+ // Verify ep direction
+ return KErrUsbEpBadDirection;
+ }
+ if (iEndpointNumber == 0)
+ {
+ // Can't issue an Ep0 write if unread data is available or writer is active
+ if (iDmaBuffers->TxIsActive() || !iDmaBuffers->IsReaderEmpty())
+ {
+ return KErrUsbEpNotReady;
+ }
+ if (iDmaBuffers->RxIsActive())
+ {
+ // if a reader is active then cancel the read
+ iDmaBuffers->RxSetInActive();
+ iController->CancelReadBuffer(iLdd, iRealEpNumber);
+ }
+ }
+ SetTransferInfo(pTfr);
+ ContinueWrite();
+ return KErrNone;
+ }
+
+
+TInt TUsbcEndpoint::ContinueWrite()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("ContinueWrite 2"));
+ TUint8* bufferAddr;
+ TPhysAddr physAddr;
+ TInt bufferLength;
+ TInt r = iDmaBuffers->TxGetNextXfer(bufferAddr, bufferLength, physAddr);
+ if (r != KErrNone) // probably already active
+ return r;
+ __KTRACE_OPT(KUSB, Kern::Printf("ContinueWrite 3"));
+ iDmaBuffers->TxSetActive();
+ TBool zlpReqd = EFalse;
+ TUint32 transferSize = iTransferInfo.iTransferSize;
+ TInt length = Min(transferSize - iBytesTransferred, (TUint32) bufferLength);
+ if (iBytesTransferred+length>=transferSize)
+ {
+ // only send a zlp if this is the last buffer of the transfer
+ zlpReqd = iTransferInfo.iZlpReqd;
+ }
+ r = iDmaBuffers->TxStoreData(iLdd->Client(), iLdd->GetClientBuffer(iEndpointNumber), length, iBytesTransferred);
+ if (r != KErrNone)
+ return r;
+ iDmaBuffers->TxSetActive();
+ iRequestCallbackInfo->SetTxBufferInfo(bufferAddr, physAddr, length);
+ iRequestCallbackInfo->iZlpReqd = zlpReqd;
+#if 0
+ for (TInt i = 0; i < iRequestCallbackInfo->iLength; i++)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Buffer[%d] = 0x%02x", i, iRequestCallbackInfo->iBufferStart[i]));
+ }
+#endif
+ r = iController->SetupWriteBuffer(*iRequestCallbackInfo);
+ return r;
+ }
+
+
+void TUsbcEndpoint::CancelTransfer(DThread* aThread, TClientBuffer *aTcb)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("CancelTransfer"));
+ if (iDmaBuffers != NULL)
+ {
+ if (iClientWritePending)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" (iClientWritePending)"));
+ iClientWritePending = EFalse;
+ iController->CancelWriteBuffer(iLdd, iRealEpNumber);
+ iDmaBuffers->TxSetInActive();
+ }
+ if (iClientReadPending)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" (iClientReadPending)"));
+ iClientReadPending = EFalse;
+ CopyToClient(aThread,aTcb);
+ }
+ }
+ }
+
+
+void TUsbcEndpoint::AbortTransfer()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Abort Transfer"));
+ if (iDmaBuffers != NULL)
+ {
+ if (iDmaBuffers->TxIsActive())
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" (iClientWritePending)"));
+ iController->CancelWriteBuffer(iLdd, iRealEpNumber);
+ iDmaBuffers->TxSetInActive();
+ }
+ if (iDmaBuffers->RxIsActive())
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" (iClientReadPending)"));
+ iController->CancelReadBuffer(iLdd, iRealEpNumber);
+ iDmaBuffers->RxSetInActive();
+ }
+ iRequestCallbackInfo->iDfc.Cancel();
+ }
+ }
+
+
+TUsbcAlternateSettingList::TUsbcAlternateSettingList()
+ : iNext(NULL),
+ iNumberOfEndpoints(0),
+ iSetting(0)
+ {
+ for (TInt i = 0; i <= KMaxEndpointsPerClient; i++)
+ {
+ iEpNumDeOrderedByBufSize[i] = -1;
+ iEndpoint[i] = NULL;
+ }
+ }
+
+
+TUsbcAlternateSettingList::~TUsbcAlternateSettingList()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcAlternateSettingList::~TUsbcAlternateSettingList()"));
+ for (TInt i = 0; i <= KMaxEndpointsPerClient; i++)
+ {
+ delete iEndpoint[i];
+ }
+ }
+
+
+TUsbcDeviceStatusQueue::TUsbcDeviceStatusQueue()
+ {
+ FlushQueue();
+ }
+
+
+void TUsbcDeviceStatusQueue::FlushQueue()
+ {
+ for (TInt i = 0; i < KUsbDeviceStatusQueueDepth; i++)
+ {
+ iDeviceStatusQueue[i] = KUsbDeviceStatusNull;
+ }
+ iStatusQueueHead = 0;
+ }
+
+
+void TUsbcDeviceStatusQueue::AddStatusToQueue(TUint32 aDeviceStatus)
+ {
+ // Only add a new status if it is not a duplicate of the one at the head of the queue
+ if (!(iStatusQueueHead != 0 &&
+ iDeviceStatusQueue[iStatusQueueHead - 1] == aDeviceStatus))
+ {
+ if (iStatusQueueHead == KUsbDeviceStatusQueueDepth)
+ {
+ // Discard item at tail of queue
+ TUint32 status;
+ GetDeviceQueuedStatus(status);
+ }
+ iDeviceStatusQueue[iStatusQueueHead] = aDeviceStatus;
+ iStatusQueueHead++;
+ }
+ }
+
+
+TInt TUsbcDeviceStatusQueue::GetDeviceQueuedStatus(TUint32& aDeviceStatus)
+ {
+ TInt r = KErrNone;
+ if (iStatusQueueHead <= 0)
+ {
+ r = KErrGeneral;
+ aDeviceStatus = KUsbDeviceStatusNull;
+ }
+ else
+ {
+ aDeviceStatus = iDeviceStatusQueue[0];
+ for(TInt i = 1; i < KUsbDeviceStatusQueueDepth; i++)
+ {
+ TUint32 s = iDeviceStatusQueue[i];
+ iDeviceStatusQueue[i - 1] = s;
+ }
+ iStatusQueueHead--;
+ iDeviceStatusQueue[KUsbDeviceStatusQueueDepth - 1] = KUsbDeviceStatusNull;
+ }
+ return r;
+ }
+
+void TClientAsynchNotify::Reset()
+{
+ iBufferRequest->Reset();
+ iClientBuffer=NULL;
+}
+
+//---