--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kernel/eka/drivers/usbcsc/d_usbcsc.cpp Thu Dec 17 09:24:54 2009 +0200
@@ -0,0 +1,3676 @@
+// 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\usbcsc\d_usbcsc.cpp
+// LDD for USB Device driver stack, using shared chunks:
+// The channel object.
+//
+//
+
+/**
+ @file d_usbcsc.cpp
+ @internalTechnology
+*/
+
+#include <drivers/usbcsc.h>
+#include "platform.h"
+
+/*****************************************************************************\
+* DUsbcScLogDevice *
+* *
+* Inherits from DLogicalDevice, the USB Shared Chunk LDD factory class *
+* *
+\*****************************************************************************/
+
+_LIT(KUsbScLddName, "Usbcsc");
+
+static const TInt KUsbRequestCallbackPriority = 2;
+
+/** Real entry point from the Kernel: return a new driver.
+ */
+DECLARE_STANDARD_LDD()
+ {
+ return new DUsbcScLogDevice;
+ }
+
+/** Create a channel on the device.
+
+ @internalComponent
+*/
+TInt DUsbcScLogDevice::Create(DLogicalChannelBase*& aChannel)
+ {
+ aChannel = new DLddUsbcScChannel;
+ return aChannel ? KErrNone : KErrNoMemory;
+ }
+
+
+DUsbcScLogDevice::DUsbcScLogDevice()
+ {
+ iParseMask = KDeviceAllowUnit;
+ iUnitsMask = 0xffffffff; // Leave units decision to the Controller
+ iVersion = TVersion(KUsbcScMajorVersion, KUsbcScMinorVersion, KUsbcScBuildVersion);
+ }
+
+
+TInt DUsbcScLogDevice::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(&KUsbScLddName);
+ }
+
+
+//
+// Return the USB controller capabilities.
+//
+void DUsbcScLogDevice::GetCaps(TDes8& aDes) const
+ {
+ TPckgBuf<TCapsDevUsbc> b;
+ b().version = iVersion;
+ Kern::InfoCopy(aDes, b);
+ }
+
+// End DUsbcScLogDevice
+
+/*****************************************************************************\
+* TUsbcScChunkInfo *
+* *
+* Where Chunk information is stored for the channel, and preseved for the *
+* life of the chunk. *
+* *
+\*****************************************************************************/
+
+void DfcChunkCleanup(TAny*);
+
+TUsbcScChunkInfo::TUsbcScChunkInfo(DLogicalDevice* aLdd)
+ : iChunk(NULL),
+ iCleanup((TDfcFn)&DfcChunkCleanup,this,Kern::SvMsgQue(),0),
+ iChunkMem(NULL),
+ iLdd(aLdd)
+ {
+ iPageNtz = (TInt8)__e32_find_ls1_32(Kern::RoundToPageSize(1));
+ }
+
+TInt TUsbcScChunkInfo::CreateChunk(TInt aTotalSize)
+ {
+ // First, reserve an TUint of memory for each of pages needed to hold aTotalSize of memory.
+ // This will form the chunk map, so that we can look up the memory geometry.
+ iAllocatedSize = (aTotalSize>>iPageNtz)*sizeof(TUint);
+ iPhysicalMap = (TUint*) Kern::AllocZ(iAllocatedSize);
+ TInt r;
+ if (iPhysicalMap==NULL)
+ r = KErrNoMemory;
+ else
+ {
+ TChunkCreateInfo chunkInfo;
+ chunkInfo.iType = TChunkCreateInfo::ESharedKernelMultiple;
+ chunkInfo.iMaxSize = aTotalSize;
+ chunkInfo.iMapAttr = EMapAttrCachedMax;
+ chunkInfo.iOwnsMemory = EFalse;
+ chunkInfo.iDestroyedDfc = &iCleanup;
+
+ TLinAddr chunkMem;
+ r = Kern::ChunkCreate(chunkInfo, iChunk, chunkMem, iChunkMapAttr);
+ iChunkMem = (TInt8*) chunkMem;
+ if (r==KErrNone)
+ iLdd->Open();
+ }
+
+ return r;
+}
+
+
+// This method requests closing the chunk.
+// Note that nothing may happen immediately, as something else may have the chunk open.
+void TUsbcScChunkInfo::Close()
+{
+ Kern::ChunkClose(iChunk);
+}
+
+
+TInt TUsbcScChunkInfo::ChunkAlloc(TInt aOffset, TInt aSize)
+ {
+ TUint pageMask = (~0)<<iPageNtz;
+ TUint rleMask = ~pageMask;
+ TUint pageSize = rleMask+1;
+ TInt r;
+ TLinAddr physAddr;
+
+ __KTRACE_OPT(KUSB, Kern::Printf("::chunkalloc AllocPhysicalRam aSize %d", aSize));
+
+ r = Epoc::AllocPhysicalRam(aSize, physAddr);
+ __KTRACE_OPT(KUSB, if (r!=KErrNone) Kern::Printf("::chunkalloc AllocPhysicalRam r=%d (Error!)", r));
+ if (r==KErrNone)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("::chunkalloc ChunkCommitPhysical iChunk 0x%x size(%d), aOffset 0x%x, aSize 0x%x phsAddr 0x%x",
+ iChunk, sizeof(DChunk), aOffset, aSize,physAddr ));
+
+ r = Kern::ChunkCommitPhysical(iChunk, aOffset, aSize, physAddr);
+ __KTRACE_OPT(KUSB, if (r!=KErrNone) Kern::Printf("::chunkalloc ChunkCommitPhysical r=%d (Error!)", r));
+
+ if (r!=KErrNone)
+ Epoc::FreePhysicalRam(physAddr, aSize);
+ else
+ { // record physical address and length in physical map
+ TInt rle;
+ TInt i=0;
+ for (rle=(aSize>>iPageNtz); rle>0; rle--, i++,physAddr+=pageSize)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("::phys offset 0x%x = 0x%x",
+ (aOffset>>iPageNtz)+i, (physAddr & pageMask) | ((rle>(TInt)rleMask)?(TInt)rleMask:rle)));
+ iPhysicalMap[(aOffset>>iPageNtz)+i] = (physAddr & pageMask) | ((rle>(TInt)rleMask)?(TInt)rleMask:rle);
+ }
+ }
+ }
+ else if (r==KErrNoMemory)
+ r = -KErrNoMemory; // Semi-expected error.
+ return r;
+ }
+
+/**
+This method retrieves the physical address of a given offset into the Chunk, and returns
+the length of contiguous physical memory from this point.
+
+@param aOffset the offset from the start of the chunk, to be queried.
+@param aPhysical a pointer to a TPhysAddr, to be filled with the physical
+ address of the memory at the given offset.
+
+@returns the length of contiguous physical memory from the given offset.
+*/
+
+TInt TUsbcScChunkInfo::GetPhysical(TInt aOffset, TPhysAddr* aPhysical)
+ {
+ // Use masks, to retrieve the two components from the physical map, we created of the memory.
+ TUint pageMask = (~0)<<iPageNtz;
+ TUint val = iPhysicalMap[aOffset>>iPageNtz];
+ *aPhysical=(val & pageMask)+(aOffset & ~pageMask);
+ return ((val & ~pageMask)<<iPageNtz) - (aOffset & ~pageMask);
+ }
+
+
+// DFC calls this fuction, which invokes the cleanup method.
+
+void DfcChunkCleanup(TAny* aChunkInfo)
+ {
+ ((TUsbcScChunkInfo*) aChunkInfo)->ChunkCleanup();
+ }
+
+
+void TUsbcScChunkInfo::ChunkCleanup()
+{
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScChunkInfo::ChunkCleanup()"));
+ TUint physAddr;
+ TInt length;
+ TInt offset = 0;
+
+ // The part of the field used for the physical page address.
+ TUint pageMask = (~0)<<iPageNtz;
+
+ // The part of the field used for the run length encoding, of the contiguous pages.
+ TUint rleMask = ~pageMask;
+ TInt records=(iAllocatedSize>>2);
+
+ while (offset < records)
+ {
+ physAddr = iPhysicalMap[offset] & pageMask;
+ length = iPhysicalMap[offset] & rleMask;
+
+ if (physAddr>0)
+ Epoc::FreePhysicalRam(physAddr, length);
+
+ offset += (length>0)?length:1;
+ }
+ Kern::Free(iPhysicalMap);
+
+ DLogicalDevice* ldd = iLdd;
+ delete this;
+ ldd->Close(NULL);
+}
+
+TInt TUsbcScChunkInfo::New(TUsbcScChunkInfo*& aChunk, TInt aSize, DLogicalDevice* aLdd)
+{
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScChunkInfo::New totalSize %d", aSize));
+
+ aChunk = new TUsbcScChunkInfo(aLdd);
+ if (aChunk==NULL)
+ {
+ return KErrNoMemory;
+ }
+
+ TInt r = aChunk->CreateChunk(aSize);
+ if (r!=KErrNone)
+ {
+ delete aChunk;
+ aChunk=NULL;
+ return r;
+ }
+
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScChunkInfo::New Created at 0x%x", aChunk->iChunkMem ));
+ return KErrNone;
+}
+
+// End TUsbcScChunkInfo
+
+/*****************************************************************************\
+* TUsbcScBuffer *
+* *
+* Represents a buffer, within a chunk. Each buffers can be used by *
+* differt endpoint on differnt alt settings *
+* *
+\*****************************************************************************/
+
+
+TInt TUsbcScBuffer::Construct(TInt aDirection, DLddUsbcScChannel* aLdd, TInt aBufferOffset, TInt aBufferEndOffset, TInt aMinReadSize, TInt aMaxPacketSize, TInt aMaxReadSize)
+ {
+ TInt r;
+#ifdef _DEBUG
+ iSequence = aBufferOffset; // Initialized at this, so that each buffer starts with a diffrent sequence number
+#endif
+ iMinReadSize = aMinReadSize;
+ TInt size = (aBufferEndOffset - aBufferOffset);
+ TInt pageSize = Kern::RoundToPageSize(1);
+ if (aMaxReadSize > 0)
+ iMaxReadSize = aMaxReadSize;
+ else
+ iMaxReadSize = pageSize + ((size/3) & ~(pageSize -1));
+ iLdd = aLdd;
+ iDirection = aDirection;
+ iMode=0;
+ iChunkInfo = aLdd->iChunkInfo;
+ iChunkAddr = (TLinAddr) (aLdd->iChunkInfo->iChunkMem); //aChunkAddr;
+
+ TInt headerSize = sizeof(TUsbcScTransferHeader)-4; // TransferHeader includes 4 bytes of data.
+
+
+ TUint maxAlignment; // Note: This is a mask for max Alignment,
+
+ if (aMaxPacketSize)
+ { // EP0 packets are not DMAed, and so dont need ialignment.
+ iAlignMask = ~3;
+ maxAlignment = 3;
+ }
+ else
+ maxAlignment = 1023; // We don't know what the alignment requirement will be until enumeration, so assume worse case.
+
+ iFirstPacket = aBufferOffset + sizeof(SUsbcScBufferHeader) + headerSize;
+ iFirstPacket = (iFirstPacket + maxAlignment) & ~maxAlignment;
+
+ iBufferStart = (SUsbcScBufferHeader *) (iChunkAddr+aBufferOffset);
+ iBufferEnd = aBufferEndOffset;
+
+ if ((iDirection&1)==KUsbcScOut)
+ iHead = iFirstPacket-headerSize;//aBufferOffset + sizeof(SUsbcScBufferHeader);
+ else
+ iSent = 0;
+
+ iStalled=0;
+ iMaxPacketSize=0;
+
+ r = iStatusList.Construct((aDirection==KUsbcScIn)?KUsbcScInRequests:KUsbcScOutRequests, iLdd->iClient);
+ if (!r)
+ {
+ iMaxPacketSize = aMaxPacketSize; // Indicates configured if ep0, otherwise not.
+ }
+ return r;
+ }
+
+
+void TUsbcScBuffer::CreateChunkBufferHeader()
+{
+ if ((iDirection&1)==KUsbcScOut)
+ {
+ iBufferStart->iHead= iHead;
+ iBufferStart->iTail= iHead; // Initially no data!
+ iBufferStart->iBilTail=iHead;
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: iHead 0x%x bufferHeader 0x%x", iHead,iBufferStart ));
+
+ // Dont need to round here, as we will round it up on endpoint change. (configuration)
+ }
+}
+
+/*
+TUsbcScBuffer::StartEndpoint
+
+This method sets the nessesary paramenters to the buffer, for use for a particular endpoint.
+
+*/
+void TUsbcScBuffer::StartEndpoint(TUsbcRequestCallback* aRequestInfo, TUint aFlags)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartEndpoint (0x%x) : ep %d(%d)",this,aRequestInfo->iEndpointNum, aRequestInfo->iRealEpNum));
+
+ iCallback=aRequestInfo;
+ iMaxPacketSize = iLdd->iController->EndpointPacketSize(iLdd, aRequestInfo->iRealEpNum);
+ iAlignMask = ~(((iMaxPacketSize+1) & 0xFFFFFFF8)-1);
+ iMode = aFlags;
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartEndpoint : max Packets %d, mask 0x%x flags 0x%x", iMaxPacketSize, iAlignMask, iMode));
+ if ((iDirection&1)==KUsbcScOut)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UsbcScOut\n"));
+ // Add dummy packet (doesnt have to be aligned, which avoids what if it changes issue)
+ // And Start next read.
+ iNeedsPacket=KEpIsStarting;
+ }
+ }
+
+
+
+void TUsbcScBuffer::Destroy()
+{
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::Destroy()"));
+ Cancel(KErrCancel);
+ if (iLdd->iController && ((iDirection&1)==KUsbcScOut))
+ { // Me must cancel reads to LDD to, an there will be no list for the callbacks to look into.
+ iLdd->iController->CancelReadBuffer(iLdd, iCallback->iRealEpNum);
+ }
+ iStatusList.Destroy();
+}
+
+
+
+TInt TUsbcScBuffer::StartDataRead()
+{
+ if (!iMaxPacketSize)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartDataRead() - Not Configured"));
+ return KErrNone;
+ }
+ if (iStatusList.iState!=ENotRunning)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartDataRead() - Already Stated! (%d)",iStatusList.iState));
+ return KErrNone;
+ }
+
+ TInt maxLength;
+ TInt freeSpace;
+ TPhysAddr physAddr;
+
+ // get next request
+ TUsbcScStatusElement* nextJob = iStatusList.Next();
+ if (nextJob == NULL)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("No more jobs"));
+ if (iMode && KUsbScCoupledRead)
+ return KErrEof;
+ iStatusList.iState=EReadingAhead;
+ }
+ else
+ iStatusList.iState=EInProgress;
+
+ TInt tail = iBufferStart->iTail;
+ TInt headerSize = sizeof(TUsbcScTransferHeader)-4; // TransferHeader includes 4 bytes of data.
+ maxLength = iChunkInfo->GetPhysical(iHead + headerSize, &physAddr); //returns all the bytes available after iHead + headerSize)
+
+ __ASSERT_DEBUG(maxLength>0,Kern::Fault("TUsbcScBuffer::StartDataRead(", __LINE__));
+
+
+ if (tail>iHead) // # # # H _ _ _ T # # # #
+ {
+ __KTRACE_OPT(KUSB,Kern::Printf("TUsbcScBuffer::StartDataRead() - tail 0x%x>head 0x%x, maxlength 0x%x", tail, iHead, maxLength));
+
+ freeSpace = (tail & iAlignMask) - (iHead +headerSize + (~iAlignMask+1) ); // Cant read right up to last buffer, or head/tail will cross.
+
+ if (freeSpace<iMinReadSize)
+ {
+ iStatusList.iState=ENotRunning;
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartDataRead() - Stall!!"));
+ return KErrOverflow; // Read STALL !! !! !!
+ }
+
+ if (freeSpace<maxLength)
+ maxLength = freeSpace;
+ }
+ if (maxLength> iMaxReadSize)
+ maxLength = iMaxReadSize;
+ // else tail<iHead (or empty) _ _ _ T # # # H _ _ _ _
+ // We would not have set iHead here if too small. So must be ok.
+
+ __ASSERT_DEBUG(maxLength>=iMinReadSize,Kern::Fault("TUsbcScBuffer::StartDataRead(", __LINE__));
+
+ TUint8* data = ((TUsbcScTransferHeader *) (iHead + iChunkAddr))->iData.b;
+ // set up callback stucture
+
+ iCallback->SetRxBufferInfo(data, physAddr, iIndexArray, iSizeArray,maxLength);
+ TInt r;
+ // Go!!
+ r = iLdd->iController->SetupReadBuffer(*iCallback);
+ if (r!=KErrNone)
+ {
+ __KTRACE_OPT(KUSB,Kern::Printf("SetupReadBuffer Error: %d, RT %d",r, iStatusList.iState));
+ iStatusList.Complete(r);
+ }
+ // After this, TUsbcScEndpoint::RequestCallback is called in a DFC.
+ // This in turn calls either TUsbcScBuffer::CompleteRead.
+ return KErrNone;
+}
+
+
+void TUsbcScBuffer::CompleteRead(TBool aStartNextRead)
+{
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::CompleteRead buff=%x",this));
+
+ // The first packet always contains the total #of bytes
+ const TInt byteCount = iCallback->iPacketSize[0];
+ const TInt packetCount = iCallback->iRxPackets;
+ iCallback->iRxPackets=0;
+ TUint flags = 0;
+
+ if (iCallback->iPacketSize[packetCount - 1] < (TUint) iMaxPacketSize)
+ flags = KUsbcScShortPacket;
+
+ UpdateBufferList(byteCount, flags, aStartNextRead);
+}
+
+
+// This method "submits" the current transfer, and starts off the next read.
+
+void TUsbcScBuffer::UpdateBufferList(TInt aByteCount,TUint aFlags, TBool aStartNextRead)
+ {
+
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UpdateBUfferLIst aByteCount %d, flags 0x%x iHead 0x%x", aByteCount, aFlags, iHead));
+
+ TInt headerSize = sizeof(TUsbcScTransferHeader)-4; // TransferHeader includes 4 bytes of data.
+ TLinAddr dummy;
+ __KTRACE_OPT(KUSB, Kern::Printf("iHead 0x%x headerSize 0x%x",iHead, headerSize));
+
+ // Find iNext
+
+ TInt next = iHead + headerSize + aByteCount; // next unused byte in buffer.
+ TInt maxLength;
+
+ // This may take a few loops before we settle on a value.
+ do
+ {
+ // round up.
+ next = (next + headerSize + ~iAlignMask) & iAlignMask;
+ maxLength = iChunkInfo->GetPhysical(next, &dummy);
+
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UpdateBUfferLIst next %x buffer end %x min-read: %x maxRun %x", next, iBufferEnd, iMinReadSize, maxLength));
+ // At the end of the buffer - wrap it if needbe.
+ if ((TUint)(next + iMinReadSize) > iBufferEnd)
+ {
+ next = iFirstPacket;
+ continue;
+ }
+ // Not enough space, move onto next block.
+ if (maxLength<iMinReadSize)
+ {
+ next+=maxLength;
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UpdateBUfferLIst Skip exhausted block. next %x max %d", next, maxLength));
+ continue;
+ }
+ }
+ while (EFalse);
+
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UpdateBUfferLIst next (pre deduct): %x, Fill in header at head: 0x%x, BuffStart: 0x%x.", next, iHead, iBufferStart));
+
+ next -= headerSize; // Move next back from the data start position, to the header start.
+
+ TUsbcScTransferHeader* header = (TUsbcScTransferHeader*) (iHead + iChunkAddr);
+
+// Create Header
+#ifdef _DEBUG
+ header->iHashId=59*(iLdd->iAlternateSetting+1)+iCallback->iRealEpNum; // Alt setting realated....
+ header->iSequence=iSequence;
+ iSequence++;
+#endif
+ header->iBytes=aByteCount;
+ header->iNext=next;
+ header->iAltSettingSeq=iLdd->iAsSeq;
+ header->iAltSetting=iLdd->iAlternateSetting;
+ header->iFlags=aFlags;
+ __KTRACE_OPT(KUSB, Kern::Printf("We set next to 0x%x", next));
+
+ iStatusList.iState=ENotRunning;
+ if (next==iBufferStart->iTail) //or (othwise is as good as full)
+ {
+ iStalled=next;
+ }
+ else
+ {
+
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UpdateBUfferLIst StartRead?? "));
+ TInt oldHead=iHead;
+ iHead = next;
+
+ if ((aStartNextRead) && (StartDataRead() == KErrOverflow))
+ { // Oh crumbs, set state as slalled.
+ if (oldHead != iBufferStart->iBilTail)
+ // If user has not read everything in the buffer
+ // then set up a stall, so that ldd get to be woken early
+ {
+ iStalled=next;
+ iHead=oldHead;
+ }
+ else // otherwise if everything is read
+ // no choice but to return what we have
+ {
+ iBufferStart->iHead = iHead;
+ }
+ }
+ else
+ {
+ iBufferStart->iHead = next;
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UpdateBUfferLIst Compleating\n"));
+ }
+ // Complete userside
+ iStatusList.Complete();
+ }
+ }
+
+void TUsbcScBuffer::PopStall()
+ {
+ if (iStalled==iBufferStart->iTail)
+ return; // Still stalled.
+
+ if (iStalled!=-1) // If not Alt packet only stall
+ {
+ // pop off packet
+ iHead = iStalled;
+ }
+ iStalled=0;
+ // If Alt setting of the popped packet is different to now
+ // Add alt setting change packet.
+
+
+ if (StartDataRead() == KErrOverflow)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::PopStall Warning: Transfer was freed, but still no space!\n"));
+ }
+
+ iBufferStart->iHead = iHead;
+ }
+
+
+
+void TUsbcScBuffer::StartDataWrite()
+ {
+
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartDataWrite()"));
+ TUsbcScStatusElement* nextJob = iStatusList.Next();
+ TBool zlpReqd;
+ TInt length;
+ TUint start;
+ TUint8* startAddr;
+ TInt maxLength;
+ TPhysAddr physAddr;
+ TInt r;
+ if (!iMaxPacketSize)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartDataWrite() - Not Configured"));
+ return;
+ }
+
+ if (nextJob == NULL)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartDataWrite() - No more jobs d=%d", iDirection));
+ if (iDirection==KUsbcScBiIn) // assume this is EP0, if this is true.
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartDataWrite() Queue Read on EP0."));
+ // Start other read again.
+ iLdd->iBuffers[iLdd->iEP0OutBuff].StartDataRead();
+ }
+ }
+ else
+ {
+ if (iStatusList.iState==ENotRunning)
+ iSent=0;
+ iStatusList.iState=EInProgress;
+
+ start = nextJob->iStart;
+ startAddr = (TUint8*) (start + ((TUint) (iChunkInfo->iChunkMem)));
+
+ length = nextJob->iLength;
+ zlpReqd = (nextJob->iFlags & KUsbcScWriteFlagsZlp) !=0;
+ // get max read length
+ maxLength = iChunkInfo->GetPhysical( start, &physAddr);
+
+ if (maxLength < length)
+ {
+ // modify request.
+ nextJob->iStart += maxLength;
+ nextJob->iLength -= maxLength;
+ // start this request.
+ iStatusList.iState=EFramgementInProgress;
+ zlpReqd=EFalse;
+ length = maxLength;
+ }
+
+ if (iDirection==KUsbcScBiIn) // this is for EP0
+ {
+ iLdd->iController->CancelReadBuffer(iLdd, iCallback->iRealEpNum);
+ iLdd->iBuffers[iLdd->iEP0OutBuff].iStatusList.iState=ENotRunning;
+ }
+
+ iCallback->SetTxBufferInfo(startAddr, physAddr, length);
+ iCallback->iZlpReqd = zlpReqd;
+ r = iLdd->iController->SetupWriteBuffer(*iCallback);
+ if (r!=KErrNone)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("SetupWriteBUffer Error: %d",r));
+ iStatusList.Complete(r);
+ }
+ }
+
+ }
+
+void TUsbcScBuffer::CompleteWrite()
+ {
+ TInt error = iCallback->iError;
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::CompleteWrite buff=%x, err=%d",this, error));
+ iSent+= iCallback->iTxBytes;
+
+ // More to send?
+ if (error || iStatusList.iState!=EFramgementInProgress)
+ {
+ // complete request with error (if one).
+ // Some data could have been transmitted, even with an error.
+ iStatusList.Complete(error);
+ }
+
+ // Start next request, or next part of this one.
+ StartDataWrite();
+
+ }
+
+// Cancels the current request's callback.
+// This is not to say it will cancel the actual operation,
+// However it will cancel any further sections of the user perceived operation
+// that are not yet started.
+void TUsbcScBuffer::Cancel(TInt aErrorCode)
+ {
+ iStatusList.CancelQueued();
+ if (iLdd->iController && ((iDirection&1)==KUsbcScIn))
+ {
+ iLdd->iController->CancelWriteBuffer(iLdd, iCallback->iRealEpNum);
+ }
+
+ iStatusList.Complete(aErrorCode);
+ }
+
+void TUsbcScBuffer::Ep0CancelLddRead()
+ {
+ // Stopping a read isn't as easy as one might think.
+ // We cancel the callback, but then check if any data was received (but not returned to us).
+ // If so, we must de-queue the request, and call the completion code.
+
+ iLdd->iController->CancelReadBuffer(iLdd, iCallback->iRealEpNum);
+ if (iCallback->iRxPackets) // received data?
+ {
+ // remove DFC (if infact sent)
+ iCallback->iDfc.Cancel();
+
+ // process the callback now, but dont start another
+ CompleteRead(EFalse);
+ }
+ }
+
+void TUsbcScBuffer::SendEp0StatusPacket(TInt aState)
+{
+ __KTRACE_OPT(KUSB, Kern::Printf(" TUsbcScBuffer::SendEp0StatusPacket(%d)", aState));
+
+ // We need to add a packet to the buffer, so we must stop the pending read, and start
+ // another after we have added out packet.
+ Ep0CancelLddRead();
+
+ TUint* state = ((TUsbcScTransferHeader *) (iHead + iChunkAddr))->iData.i;
+ *state = aState;
+ UpdateBufferList(4,KUsbcScStateChange);
+}
+
+// End TUsbcScBuffer
+
+/*****************************************************************************\
+* TUsbcScStatusList *
+* *
+* This is a list of read or write requests, containing user status *
+* requests, that should later be completed. *
+* *
+\*****************************************************************************/
+
+/**
+Constructor for TUsbcScStatusList.
+
+@param aSize is the number of requests to allow at any one time. This value
+ must be a power of two, for correct operation.
+
+@returns KErrNoMemory if memory allocation failure, otherwise KErrNone.
+*/
+
+TInt TUsbcScStatusList::Construct(TInt aSize, DThread* aClient)
+ {
+ iSize=aSize;
+ iHead = 0;
+ iLength = 0;
+ iClient = aClient;
+ iElements=(TUsbcScStatusElement *) Kern::AllocZ(sizeof(TUsbcScStatusElement)*aSize);
+ return (iElements==NULL)?KErrNoMemory:KErrNone;
+ };
+
+
+// StatusList must be inactive before destroying.
+void TUsbcScStatusList::Destroy()
+ {
+ if (iState!=ENotRunning)
+ Kern::Fault("TUsbcScStatusList::Destroy", __LINE__);
+ if (iElements)
+ {
+ Kern::Free(iElements);
+ iElements=NULL;
+ }
+ iClient=NULL;
+}
+
+void TUsbcScStatusList::Pop()
+ {
+ if (iLength>0)
+ {
+ iLength--;
+ iHead = ((iHead+1) & (iSize-1));
+ }
+ }
+
+TUsbcScStatusElement* TUsbcScStatusList::Next()
+ {
+ return (iLength==0)?NULL:&(iElements[iHead]);
+ }
+
+TInt TUsbcScStatusList ::Add(TRequestStatus* aStatus, TInt aLength, TUint aStart, TUint aFlags)
+ {
+ __KTRACE_OPT(KUSB,Kern::Printf("Adding request. iLength %d iSize %d", iLength, iSize));
+ if (iLength<iSize)
+ {
+ TUsbcScStatusElement& e = iElements[((iHead+iLength) & (iSize-1))];
+ e.iStatus = aStatus;
+ e.iLength = aLength;
+ e.iStart = aStart;
+ e.iFlags = aFlags;
+ iLength++;
+ __KTRACE_OPT(KUSB,Kern::Printf("Adding request. new iLength %d", iLength));
+
+ return KErrNone;
+ }
+ else
+ return KErrInUse;
+ }
+
+
+
+// This method cancels any requests that have yet to be started.
+
+void TUsbcScStatusList::CancelQueued(TInt aError)
+{
+ if ((iLength==0) || ((iState!=ENotRunning) && (iLength==1))) // Nothing to do.
+ return;
+ TInt elements2Complete = iLength - (iState?1:0);
+ TInt head = iHead;
+ iLength = 0;
+ if (iState) // If (iState != ENotRunning), complete all elements excepting the one at head
+ {
+ head = ((head+1) & (iSize-1)); // To iterate through the queue
+ iLength = 1;
+ }
+ // complete them all.
+ for (; elements2Complete>0; elements2Complete--)
+ {
+ Kern::RequestComplete(iClient, iElements[head].iStatus, aError);
+ head = ((head+1) & (iSize-1));
+ }
+
+}
+
+
+/* This method Completes the head status request, and pops it from its list.
+This version of Complete is to be used in cases where the next request is not
+chained - usually because of an error.
+
+@Param aError - the code to complete with.
+
+returns KErrNotFound if there was no request to complete
+*/
+
+
+TInt TUsbcScStatusList::Complete(TInt aError)
+ {
+ if (iState==ENotRunning)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScStatusList::Complete() - iState == ENotRunning!"));
+ }
+ else
+ {
+ iState=ENotRunning;
+ if (iLength==0)
+ return KErrNotFound;
+
+ Kern::RequestComplete(iClient, iElements[iHead].iStatus, aError);
+
+ iLength--;
+ iHead = ((iHead+1) & (iSize-1));
+ }
+ return KErrNone;
+ }
+
+
+/* This method Completes the head status request, and pops it from its list. (If found.)
+This version of Complete is to be used in cases where the request is successful, and
+ next request after this has (if present) been chained.
+*/
+
+void TUsbcScStatusList::Complete()
+ {
+ if (iLength==0)
+ return;
+ __KTRACE_OPT(KUSB, Kern::Printf("Completing request. iLength %d", iLength));
+
+ Kern::RequestComplete(iClient, iElements[iHead].iStatus, KErrNone);
+
+ iLength--;
+ iHead = ((iHead+1) & (iSize-1));
+ }
+
+// End TUsbcScStatusList
+
+/*****************************************************************************\
+* TRealizeInfo *
+* *
+* Used by DLddUsbcScChannel::RealizeInterface to set up the chunk *
+* *
+\*****************************************************************************/
+
+// Init
+//
+// This method works out the number potential maximum number of endpoints
+// and the number of alt settings. With this information it allocs
+// the necessary space for the given stucture to store information about
+// the endpoints.
+// This is intended to be called by RealizeInterface. This stucture is
+// intended to be only temporary, and the space will be freed with Free()
+// before RealizeInteface has finished.
+
+void TRealizeInfo::Init(TUsbcScAlternateSettingList* aAlternateSettingList)
+{
+ iAlternateSettingList = aAlternateSettingList;
+ iMaxEndpoints=0;
+ iTotalSize =0;
+ iTotalBuffers=0;
+ iAltSettings =0;
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: work out max endpoint"));
+ // Work out max endpoints and number of alternate settings.
+
+ if (iAlternateSettingList)
+ {
+ TUsbcScAlternateSetting* alt = iAlternateSettingList->iHead;
+ while (alt != NULL)
+ {
+ iAltSettings++;
+ if (alt->iNumberOfEndpoints>iMaxEndpoints)
+ iMaxEndpoints = alt->iNumberOfEndpoints;
+ // could work out in/out specifics, but unnecessary.
+ alt = alt->iNext;
+ };
+ }
+
+ // Alloc some temporary working space for temp endpoint metadata
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: Alloc temp. Maxendpoints %d", iMaxEndpoints));
+ TInt inout;
+ for (inout=KUsbcScIn; inout<KUsbcScDirections; inout++)
+ {
+ iBufs[inout].iEp = (TUsbcScEndpoint **) Kern::AllocZ(iAltSettings*iMaxEndpoints*sizeof(TUsbcScEndpoint *));
+ iBufs[inout].iSizes = (TInt *) Kern::AllocZ(iMaxEndpoints*sizeof(TInt));
+ }
+}
+
+// CopyAndSortEndpoints
+//
+// This method copies pointers to the endpoint records into TRealizeInfo
+// such that they are sorted in order of size per alt setting.
+// In and Out endpoints are separated, and kept separate.
+// The provided data structure is assumed to have been initialised with
+// Realize_InitRealizeInfo.
+//
+// Return KErrArgument if the direction field is neither In or Out.
+//
+
+TInt TRealizeInfo::CopyAndSortEndpoints()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: copy And sort"));
+
+ TInt altSetting = 0;
+ TInt endpointOffs;
+ TInt endpoint;
+ TInt altEp;
+ TInt inout;
+ TBool placed;
+ TUsbcScAlternateSetting* alt;
+ TEndpointSortBufs* bufsd;
+
+ if (iAlternateSettingList)
+ {
+ for (alt = iAlternateSettingList->iHead;alt!=NULL;alt = alt->iNext )
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: AlternateSetting %x", alt));
+
+ iBufs[KUsbcScIn].iEps =0;
+ iBufs[KUsbcScOut].iEps =0;
+
+ // For alt setting, iterate eps
+ for (altEp=1; altEp <= alt->iNumberOfEndpoints; altEp++)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: Endpoint to add: %d",altEp));
+
+ TUsbcScEndpoint* nextEp = alt->iEndpoint[altEp];
+
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: ep Buffer Size: %d",nextEp->EndpointInfo()->iBufferSize));
+
+ inout = (nextEp->EndpointInfo()->iDir==KUsbEpDirIn)?KUsbcScIn:
+ (nextEp->EndpointInfo()->iDir==KUsbEpDirOut)?KUsbcScOut:KUsbcScUnknown;
+ if (inout==KUsbcScUnknown)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: KUsbcScUnknown %x",nextEp->EndpointInfo()->iDir));
+ return KErrArgument;
+ }
+
+ bufsd = &(iBufs[inout]);
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: ep direction: %x # endpoints %d", inout, bufsd->iEps));
+
+
+ // find and position ep, and insert.
+
+ if (bufsd->iEps==0) // First entry.
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: Add first endpoint"));
+ endpointOffs = altSetting*iMaxEndpoints;
+ bufsd->iEp[endpointOffs] = nextEp;
+ }
+ else
+ {
+ placed = EFalse;
+ // Move down the list, until we find the right place.
+ for (endpoint=bufsd->iEps-1; endpoint>-1; endpoint--)
+ {
+ endpointOffs = altSetting*iMaxEndpoints + endpoint;
+ if (bufsd->iEp[endpointOffs]->EndpointInfo()->iBufferSize < nextEp->EndpointInfo()->iBufferSize)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: Shift Endpoint %d", endpoint));
+
+ bufsd->iEp[endpointOffs+1] = bufsd->iEp[endpointOffs];
+ }
+ else
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: Insert After Endpoint %d", endpoint));
+
+ bufsd->iEp[endpointOffs+1] = nextEp;
+ placed = ETrue;
+ break;
+ }
+ } // end for endpoint
+ if (!placed) // if we didn't place it, it must be the biggest so far, so goes at the top.
+ bufsd->iEp[0] = nextEp;
+ } // endif
+ bufsd->iEps++;
+ } // for altEp
+ altSetting++;
+ } // for alt
+ }// if iAltsettingList
+ return KErrNone;
+ }
+
+// CalcBuffSizes
+//
+// This works out the sizes of all the buffers, and stores the result in aBufInfo
+// based on the buffer information provided in the same structure.
+// Realize_CopyAndSortEndpoints is used to fill the structure with the informaition
+// required.
+
+void TRealizeInfo::CalcBuffSizes()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: Calculate Buffers"));
+
+ TInt endpoint;
+ TInt inout;
+ TInt altSetting;
+ TUsbcScEndpoint* nextEp;
+ TInt bufferSize;
+ TEndpointSortBufs* bufsd;
+
+ for (inout=KUsbcScIn; inout<KUsbcScDirections; inout++)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: Direction: %d", inout));
+
+
+ bufsd = &(iBufs[inout]);
+ // for each row, ie, buffer, find largest buffer need.
+ for (endpoint=0; endpoint<iMaxEndpoints; endpoint++)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: endpoint %d", endpoint));
+ TInt bufMaxSize=0;
+ for (altSetting=0; altSetting< iAltSettings; altSetting++)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: altSetting %d", altSetting));
+ nextEp= bufsd->iEp[altSetting* iMaxEndpoints + endpoint];
+ if (nextEp!=NULL)
+ {
+ bufferSize = nextEp->EndpointInfo()->iBufferSize;
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: comparing size %d", bufferSize));
+ if (bufferSize> bufMaxSize)
+ bufMaxSize = bufferSize;
+ }
+ } // for altsetting
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: bufMaxSize %d", bufMaxSize));
+ bufsd->iSizes[endpoint] = bufMaxSize;
+ if (bufMaxSize>0)
+ {
+ iTotalSize += bufsd->iSizes[endpoint];
+ iTotalBuffers++;
+ }
+ } // for endpoint
+ } // for in/out
+}
+
+// Free
+//
+// Cleans up after Init()
+
+void TRealizeInfo::Free()
+ {
+ TInt inout;
+ for (inout=KUsbcScIn; inout<KUsbcScDirections; inout++)
+ {
+ Kern::Free(iBufs[inout].iEp);
+ Kern::Free(iBufs[inout].iSizes);
+ }
+ }
+
+// End TRealizeInfo
+
+
+// LayoutChunkHeader
+//
+// Sets up some geometry for the chunk;
+
+void TRealizeInfo::LayoutChunkHeader(TUsbcScChunkInfo* aChunkInfo)
+{
+ // First set up the indexes to the header structures.
+ TUsbcScChunkHdrOffs* chkHdr = (TUsbcScChunkHdrOffs*) aChunkInfo->iChunkMem;
+
+ chkHdr->iBuffers = sizeof(TUsbcScChunkHdrOffs); // First struct just after this one.
+ iChunkStuct = (TUsbcScChunkBuffersHeader*) ( (TInt) aChunkInfo->iChunkMem + chkHdr->iBuffers);
+
+ // Store number of buffers in chunk
+ iChunkStuct->iRecordSize = sizeof(TUsbcScBufferRecord);
+ iChunkStuct->iNumOfBufs=iTotalBuffers;
+
+ iAltSettingsTbl = (TUsbcScChunkAltSettingHeader*) &(iChunkStuct->iBufferOffset[(iTotalBuffers+2)*sizeof(TUsbcScBufferRecord)]); // 2 extra for EP0 in and out.
+
+ chkHdr->iAltSettings = (TUint) iAltSettingsTbl - (TUint) aChunkInfo->iChunkMem;
+
+ iAltSettingsTbl->iEpRecordSize = sizeof(TUint);
+ iAltSettingsTbl->iNumOfAltSettings = iAltSettings;
+
+
+ TInt tableOffset = (TUint) iAltSettingsTbl->iAltTableOffset - (TUint) aChunkInfo->iChunkMem + iAltSettings*sizeof(TInt);
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: table offset: 0x%x, altTble %x iChnkMem %x altSettings %x",tableOffset, iAltSettingsTbl, aChunkInfo->iChunkMem, iAltSettings ));
+
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: populate chunk - create alt settings table"));
+
+ // Create alt settings table. Set each element of altsettings table, to each induivatual alt setting table.
+ // then fill in the number of endpoints for that alt setting, in the table.
+
+ TInt* noEpForAlt;
+ TInt altSetting;
+ TUsbcScAlternateSetting* alt;
+ if (iAlternateSettingList)
+ {
+ alt = iAlternateSettingList->iHead;
+ for (altSetting=0; altSetting<iAltSettings; altSetting++)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: altSetting %d, tableOffset %d", altSetting, tableOffset));
+
+ iAltSettingsTbl->iAltTableOffset[altSetting] = tableOffset;
+ noEpForAlt = (TInt*) &aChunkInfo->iChunkMem[tableOffset];
+
+ *noEpForAlt = alt->iNumberOfEndpoints; // Set NumberofEndpoints field in Altsetting table
+ tableOffset+= sizeof(TInt)+ alt->iNumberOfEndpoints*sizeof(TUsbcScHdrEndpointRecord);
+ alt = alt->iNext;
+ }
+ }
+
+} // end LayoutChunkHeader
+
+
+
+/*****************************************************************************\
+* DLddUsbcScChannel *
+* *
+* Inherits from DLogicalDevice, the USB Shared Chunk LDD factory class *
+* *
+\*****************************************************************************/
+
+//
+// Constructor
+//
+DLddUsbcScChannel::DLddUsbcScChannel()
+ : iValidInterface(EFalse),
+ iAlternateSettingList(NULL),
+ iEndpoint(NULL),
+ iCompleteAllCallbackInfo(this, DLddUsbcScChannel::EmergencyCompleteDfc, KUsbRequestCallbackPriority),
+ iStatusChangePtr(NULL),
+ iStatusCallbackInfo(this, DLddUsbcScChannel::StatusChangeCallback, KUsbRequestCallbackPriority),
+ iEndpointStatusChangePtr(NULL),
+ iEndpointStatusCallbackInfo(this, DLddUsbcScChannel::EndpointStatusChangeCallback,
+ KUsbRequestCallbackPriority),
+ iOtgFeatureChangePtr(NULL),
+ iOtgFeatureCallbackInfo(this, DLddUsbcScChannel::OtgFeatureChangeCallback, KUsbRequestCallbackPriority),
+ iNumberOfEndpoints(0),
+ iDeviceState(EUsbcDeviceStateUndefined),
+ iOwnsDeviceControl(EFalse),
+ iAlternateSetting(0),
+ iAsSeq(0),
+ iStatusFifo(NULL),
+ iUserKnowsAltSetting(ETrue),
+ iDeviceStatusNeeded(EFalse),
+ iChannelClosing(EFalse),
+ iRealizeCalled(EFalse),
+ iChunkInfo(NULL),
+ iNumBuffers(-1),
+ iBuffers(NULL),
+ iEp0Endpoint(NULL)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcScChannel::DLddUsbcScChannel()"));
+ iClient = &Kern::CurrentThread();
+ iClient->Open();
+ for (TInt i = 1; i < KUsbcMaxRequests; i++)
+ {
+ iRequestStatus[i] = NULL;
+ }
+ }
+
+
+//
+// Destructor
+//
+
+DLddUsbcScChannel::~DLddUsbcScChannel()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcScChannel::~DLddUsbcScChannel()"));
+ if (iController)
+ {
+ iStatusCallbackInfo.Cancel();
+ iEndpointStatusCallbackInfo.Cancel();
+ iOtgFeatureCallbackInfo.Cancel();
+ iCompleteAllCallbackInfo.Cancel();
+ DestroyAllInterfaces();
+ if (iOwnsDeviceControl)
+ {
+ iController->ReleaseDeviceControl(this);
+ iOwnsDeviceControl = EFalse;
+ }
+ iController->DeRegisterClient(this);
+ iController=NULL;
+ DestroyEp0();
+ if (iStatusFifo!=NULL)
+ {
+ delete iStatusFifo;
+ }
+ }
+ __KTRACE_OPT(KUSB, Kern::Printf("Closing buffers"));
+ if (iBuffers)
+ {
+ TInt i;
+ for (i=0; i<(iNumBuffers+2); i++)
+ {
+ iBuffers[i].Destroy();
+ }
+ Kern::Free(iBuffers);
+ }
+
+ if (iRealizeCalled)
+ {
+ // Close Chunk
+ iChunkInfo->Close();
+ // ChunkInfo will delete itself with DFC, but the pointer here is no longer needed.
+ iChunkInfo=NULL;
+ }
+ __KTRACE_OPT(KUSB, Kern::Printf("about to SafeClose"));
+ Kern::SafeClose((DObject*&)iClient, NULL);
+ }
+
+
+//
+// DoCreate - Create channel
+//
+
+TInt DLddUsbcScChannel::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 USBCSC.LDD (USB Driver)")))
+ {
+ return KErrPermissionDenied;
+ }
+
+ iController = DUsbClientController::UsbcControllerPointer();
+
+ if (!iController)
+ {
+ return KErrGeneral;
+ }
+
+ iStatusFifo = new TUsbcDeviceStatusQueue;
+ if (iStatusFifo == NULL)
+ {
+ return KErrNoMemory;
+ }
+
+ if (!Kern::QueryVersionSupported(TVersion(KUsbcScMajorVersion, KUsbcScMinorVersion, KUsbcScBuildVersion), aVer))
+ {
+ return KErrNotSupported;
+ }
+
+ // set up the correct DFC queue
+ SetDfcQ(iController->DfcQ(0)); // sets the channel's dfc queue
+ 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;
+
+ return r;
+ }
+// end DoCreate.
+
+
+//
+// HandleMsg
+//
+// Events from userside arrive here, and delegated to either DoRequest, DoControl or DoCancel.
+//
+
+void DLddUsbcScChannel::HandleMsg(TMessageBase* aMsg)
+ {
+ TThreadMessage& m = *(TThreadMessage*)aMsg;
+ TInt id = m.iValue;
+ __KTRACE_OPT(KUSB, Kern::Printf("HandleMsg 0x%x", id));
+
+ if (id == (TInt) ECloseMsg)
+ {
+ iChannelClosing = ETrue;
+ m.Complete(KErrNone, EFalse);
+ return;
+ }
+
+ TInt r;
+ if (id < 0)
+ {
+ // DoRequest
+ TRequestStatus* pS = (TRequestStatus*) m.Ptr0();
+ r = DoRequest(~id, pS, m.Ptr1(), m.Ptr2());
+ m.Complete(r, ETrue);
+ }
+ else if (id & RDevUsbcScClient::ERequestCancel)
+ {
+ // DoCancel
+ r = DoCancel(id, (TUint) m.Ptr0(), (TUint) m.Ptr1());
+ m.Complete(r, ETrue);
+ }
+ else
+ {
+ // DoControl
+ r = DoControl(id, m.Ptr0(), m.Ptr1());
+ m.Complete(r, ETrue);
+ }
+ }
+// end HandleMsg.
+
+
+#define BREAK_IF_NULL_ARG(a,r) if (a==NULL) { r = KErrArgument; __KTRACE_OPT(KUSB,Kern::Printf("NULL Argument")); break; }
+
+//
+// DoRequest - Asynchronous requests
+//
+// Overrides pure virtual, called by HandleMsg. (Above)
+//
+TInt DLddUsbcScChannel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)
+ {
+ TInt reqNo = aReqNo & RDevUsbcScClient::KFieldIdMask;
+ TInt r = KErrNone; // return via request notify
+ TBool needsCompletion =EFalse;
+
+ __KTRACE_OPT(KUSB, Kern::Printf("DoRequest 0x%08x", aReqNo));
+
+ if ((reqNo>RDevUsbcScClient::ERequestReadDataNotify) &&
+ (reqNo<RDevUsbcScClient::ERequestMaxRequests))
+ {
+ if (iRequestStatus[reqNo])
+ {
+ PanicClientThread(ERequestAlreadyPending);
+ return 0;
+ }
+ iRequestStatus[reqNo] = aStatus;
+ }
+
+ switch (reqNo)
+ {
+ case RDevUsbcScClient::ERequestWriteData:
+ {
+ TInt buffer = (aReqNo>>RDevUsbcScClient::KFieldBuffPos)&RDevUsbcScClient::KFieldBuffMask;
+ __KTRACE_OPT(KUSB, Kern::Printf("ERequestWriteData"));
+ BREAK_IF_NULL_ARG(a2,r);
+
+ r = DoWriteData( aStatus, buffer, (TInt) a1 /*Start*/, (TInt) a2 /* Length */,
+ aReqNo>>RDevUsbcScClient::KFieldFlagsPos ); // Flags
+ break;
+ }
+ case RDevUsbcScClient::ERequestReadDataNotify:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("ERequestReadDataNotify"));
+ return DoReadDataNotify(aStatus, (TInt) a1, (TInt) a2); // a1 = aBufferNumber, a2 - aLength;
+ }
+
+ case RDevUsbcScClient::ERequestAlternateDeviceStatusNotify:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("ERequestAlternateDeviceStatusNotify"));
+ BREAK_IF_NULL_ARG(a1,r);
+ iDeviceStatusNeeded = ETrue;
+ iStatusChangePtr = a1;
+ needsCompletion = AlternateDeviceStateTestComplete();
+ break;
+ }
+ case RDevUsbcScClient::ERequestReEnumerate:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("ERequestReEnumerate"));
+ // If successful, this will complete via the status notification.
+ r = iController->ReEnumerate();
+ break;
+ }
+ case RDevUsbcScClient::ERequestEndpointStatusNotify:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("ERequestEndpointStatusNotify"));
+ BREAK_IF_NULL_ARG(a1,r);
+
+ iEndpointStatusChangePtr = a1;
+ break;
+ }
+ case RDevUsbcScClient::ERequestOtgFeaturesNotify:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("ERequestOtgFeaturesNotify"));
+ BREAK_IF_NULL_ARG(a1,r);
+
+ iOtgFeatureChangePtr = a1;
+ break;
+ }
+ default:
+ r = KErrNotSupported;
+ }
+
+ if ((needsCompletion) || (r != KErrNone))
+ {
+ iRequestStatus[reqNo] = aStatus;
+ Kern::RequestComplete(iClient, iRequestStatus[reqNo], r);
+ }
+ return KErrNone;
+ }
+// end DoRequest.
+
+
+//
+// DoReadDataNotify
+//
+// This method sets up the request to facilitate the userside being notifed when new data has been read.
+//
+TInt DLddUsbcScChannel::DoReadDataNotify(TRequestStatus* aStatus, TInt aBufferNum, TInt aLength)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" DLddUsbcScChannel::DoReadDataNotify(x, %d, 0x%x)", aBufferNum, aLength));
+ TInt r = KErrNone;
+ // check range
+ if ((aBufferNum<0) || (aBufferNum>=iNumBuffers)) // Indirectly checks that we are set up.
+ {
+ if (aBufferNum!=KUsbcScEndpointZero)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" DLddUsbcScChannel::DoReadDataNotify : Bad Buffer Number!"));
+ return KErrArgument;
+ }
+ else
+ {
+ aBufferNum = iEP0OutBuff;
+ }
+ }
+ else
+ {
+ // check direction
+ if (iBuffers[aBufferNum].iDirection!=KUsbcScOut)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" DLddUsbcScChannel::DoReadDataNotify : Bad Buffer Direction!"));
+ return KErrNotSupported;
+ }
+ if (!Configured())
+ return KErrUsbInterfaceNotReady;
+ }
+ SUsbcScBufferHeader* scBuffer = (SUsbcScBufferHeader*) iBuffers[aBufferNum].iBufferStart;
+
+ __KTRACE_OPT(KUSB, Kern::Printf(" DLddUsbcScChannel::DoReadDataNotify head %x tail %x", iBuffers[aBufferNum].iHead , scBuffer->iTail ));
+
+ if (iBuffers[aBufferNum].iHead != scBuffer->iBilTail)
+ r = KErrCompletion;
+ else
+ if (iBuffers[aBufferNum].iStalled)
+ {
+ iBuffers[aBufferNum].PopStall();
+ return KErrCompletion;
+ }
+ else
+ r = iBuffers[aBufferNum].iStatusList.Add(aStatus, aLength, 0,0);
+
+ if (iBuffers[aBufferNum].iStatusList.iState==ENotRunning)
+ {
+ iBuffers[aBufferNum].StartDataRead();
+ }
+ else
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Job in Progress!"));
+ }
+ return r;
+ }
+// end DoReadDataNotify.
+
+
+
+//
+// DoWriteData
+//
+// This method sets up the request to write data to USB from userside.
+//
+TInt DLddUsbcScChannel::DoWriteData(TRequestStatus* aStatus,TInt aBufferNum, TUint aStart, TUint aLength, TUint aFlags)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" DLddUsbcScChannel::DoWriteData(%d, 0x%x, 0x%x, 0x%x)", aBufferNum, aStart, aLength, aFlags));
+ if (!iUserKnowsAltSetting)
+ return KErrEof;
+ // Check Buffer Number
+ if ((aBufferNum<0) || (aBufferNum>=iNumBuffers))
+ {
+ if ((TUint)aBufferNum!=RDevUsbcScClient::KFieldBuffMask) // KUsbcScEndpointZero & KFieldBuffMas = KFieldBuffMas;
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" DLddUsbcScChannel::DoWriteData : Bad Buffer Number!"));
+ return KErrArgument;
+ }
+ else
+ {
+ aBufferNum = iEP0InBuff;
+ }
+ }
+ else
+ {
+ // check direction
+ if (iBuffers[aBufferNum].iDirection!=KUsbcScIn)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" DLddUsbcScChannel::DoWriteData Bad endpoint Direction"));
+ return KErrArgument;
+ }
+ }
+
+ TUsbcScBuffer& buf=iBuffers[aBufferNum];
+
+ if ((aStart< (((TLinAddr) buf.iBufferStart)-buf.iChunkAddr)) || ((aStart+aLength)>iBuffers[aBufferNum].iBufferEnd))
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" DLddUsbcScChannel::DoWriteData Bad Range aStart or aLength 0x%x > 0x%x + 0x%x < 0x%x", (((TLinAddr) buf.iBufferStart)-buf.iChunkAddr),aStart, aLength, iBuffers[aBufferNum].iBufferEnd ));
+ return KErrArgument;
+ }
+
+ if ( (aBufferNum != iEP0InBuff) && !Configured())
+ return KErrUsbInterfaceNotReady;
+
+ if (aStart & ~buf.iAlignMask)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::DoDataWrite: address 0x%x unaligned.",aStart));
+ return KErrArgument;
+ }
+
+ TInt r = iBuffers[aBufferNum].iStatusList.Add(aStatus, aLength, aStart, aFlags); //update
+
+ if (iBuffers[aBufferNum].iStatusList.iState==ENotRunning)
+ {
+ iBuffers[aBufferNum].StartDataWrite();
+ }
+ else
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Job in Progress!"));
+ }
+
+
+ return r;
+ }
+// end DoWriteData.
+
+
+//
+// Cancel an outstanding request // Cancel need reworking.
+//
+TInt DLddUsbcScChannel::DoCancel(TInt aReqNo, TUint aBuff, TUint aSpair)
+ {
+ TInt r = KErrNone;
+ TInt direction=KUsbcScOut;
+
+ __KTRACE_OPT(KUSB, Kern::Printf("DoCancel: 0x%x aBuff 0x%x", aReqNo, aBuff));
+ switch (aReqNo)
+ {
+ case RDevUsbcScClient::ERequestCancel:
+ TInt buffer;
+ TInt mask;
+
+ for (buffer=1, mask=1; buffer<iNumBuffers; buffer++,mask<<=1)
+ if (aBuff&mask)
+ iBuffers[buffer].Cancel(KErrCancel);
+
+ return KErrNone;
+
+ // coverity[missing_break]
+ case RDevUsbcScClient::ERequestWriteDataCancel:
+ direction = KUsbcScIn;
+ case RDevUsbcScClient::ERequestReadDataNotifyCancel:
+ __KTRACE_OPT(KUSB, Kern::Printf("DoCancel Direction %d endpoints: 0x%x",direction, aReqNo));
+
+ if (((TInt)aBuff)==KUsbcScEndpointZero) // EP0 is bi-directional, so pick correct buffer for call type
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoCancel Cancel Endpoint 0/%d",direction));
+ iEp0Endpoint->AbortTransfer();
+ if (direction==KUsbcScIn)
+ aBuff=iEP0InBuff;
+ else
+ aBuff=iEP0OutBuff;
+ }
+ else if ((TInt)aBuff >= iNumBuffers) // check buff no range.
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoCancel Error: Bad buffer number"));
+ return KErrArgument;
+ }
+
+ if ((iBuffers[aBuff].iDirection&1)!=direction) // Does direction match call type?
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoCancel Error: Bad buffer direction"));
+ return KErrArgument;
+ }
+ iBuffers[aBuff].iStatusList.CancelQueued();
+ iBuffers[aBuff].Cancel(KErrCancel);
+
+ return KErrNone;
+
+ case RDevUsbcScClient::ERequestAlternateDeviceStatusNotifyCancel:
+ __KTRACE_OPT(KUSB, Kern::Printf("DoCancel: ERequestAlternateDeviceStatusNotify 0x%x", aReqNo));
+ iDeviceStatusNeeded = EFalse;
+ iStatusFifo->FlushQueue();
+ if (iStatusChangePtr)
+ {
+ TInt deviceState = iController->GetDeviceStatus();
+ r = Kern::ThreadRawWrite(iClient, iStatusChangePtr, &deviceState, sizeof(deviceState), iClient);
+ if (r != KErrNone)
+ PanicClientThread(r);
+ iStatusChangePtr = NULL;
+ }
+ break;
+
+ case RDevUsbcScClient::ERequestReEnumerateCancel:
+ __KTRACE_OPT(KUSB, Kern::Printf("DoCancel ERequestReEnumerate: 0x%x", aReqNo));
+ break;
+
+ case RDevUsbcScClient::ERequestEndpointStatusNotifyCancel:
+ __KTRACE_OPT(KUSB, Kern::Printf("DoCancel ERequestEndpointStatusNotify: 0x%x", aReqNo));
+ CancelNotifyEndpointStatus();
+ break;
+
+ case RDevUsbcScClient::ERequestOtgFeaturesNotifyCancel:
+ __KTRACE_OPT(KUSB, Kern::Printf("DoCancel ERequestOtgFeaturesNotify: 0x%x", aReqNo));
+ CancelNotifyOtgFeatures();
+ break;
+
+ default:
+ __KTRACE_OPT(KUSB, Kern::Printf("DoCancel Unknown! 0x%x", aReqNo));
+ return KErrArgument;
+ }
+
+ Kern::RequestComplete(iClient,iRequestStatus[aReqNo & ~RDevUsbcScClient::ERequestCancel], KErrCancel);
+ return r;
+ }
+
+
+void DLddUsbcScChannel::CancelNotifyEndpointStatus()
+ {
+ if (iEndpointStatusChangePtr)
+ {
+ TUint epBitmap = 0;
+ for (TInt i = 1; i <= iNumberOfEndpoints; i++)
+ {
+ TInt v = iController->GetEndpointStatus(this, iEndpoint[i]->RealEpNumber());
+ TUint b;
+ (v == EEndpointStateStalled) ? b = 1 : b = 0;
+ epBitmap |= b << i;
+ }
+ TInt r=Kern::ThreadRawWrite(iClient, iEndpointStatusChangePtr, (TUint8*) &epBitmap, sizeof(epBitmap), iClient);
+ if (r != KErrNone)
+ PanicClientThread(r);
+ iEndpointStatusChangePtr = NULL;
+ }
+ }
+
+void DLddUsbcScChannel::CancelNotifyOtgFeatures()
+ {
+ if (iOtgFeatureChangePtr)
+ {
+ TUint8 features;
+ iController->GetCurrentOtgFeatures(features);
+ TInt r=Kern::ThreadRawWrite(iClient, iOtgFeatureChangePtr, (TUint8*)&features, sizeof(features), iClient);
+ if (r != KErrNone)
+ PanicClientThread(r);
+ iOtgFeatureChangePtr = NULL;
+ }
+ }
+
+
+
+//
+// DoControl - Synchronous requests
+//
+// Called from HandleMsg.
+
+TInt DLddUsbcScChannel::DoControl(TInt aFunction, TAny* a1, TAny* a2)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DoControl: %d", aFunction));
+
+ TInt r = KErrNone;
+ TInt ep, param;
+ TUsbcScEndpoint* pEndpoint;
+ TPtrC8 pZeroDesc(NULL, 0);
+ TEndpointDescriptorInfo epInfo;
+ TUsbcScIfcInfo ifcInfo;
+ TCSDescriptorInfo desInfo;
+ TUsbcEndpointResource epRes;
+
+ switch (aFunction)
+ {
+ case RDevUsbcScClient::EControlEndpointZeroRequestError:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlEndpointZeroRequestError"));
+ r = KErrNone;
+ if (iOwnsDeviceControl || (iValidInterface && iDeviceState == EUsbcDeviceStateConfigured))
+ {
+ iController->Ep0Stall(this);
+ }
+ else
+ {
+ if (iDeviceState != EUsbcDeviceStateConfigured)
+ r = KErrUsbDeviceNotConfigured;
+ else
+ r = KErrUsbInterfaceNotReady;
+ }
+ break;
+
+ case RDevUsbcScClient::EControlGetAlternateSetting:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetAlternateSetting"));
+ if (iValidInterface && iDeviceState == EUsbcDeviceStateConfigured)
+ {
+ r = iController->GetInterfaceNumber(this, param);
+ if (r == KErrNone)
+ {
+ r = Kern::ThreadRawWrite(iClient, a1, ¶m, sizeof(param), iClient);
+ if (r != KErrNone)
+ PanicClientThread(r);
+ }
+ }
+ else
+ {
+ if (iDeviceState != EUsbcDeviceStateConfigured)
+ r = KErrUsbDeviceNotConfigured;
+ else
+ r = KErrUsbInterfaceNotReady;
+ }
+ break;
+
+ case RDevUsbcScClient::EControlDeviceStatus:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlDeviceStatus"));
+ param = iController->GetDeviceStatus();
+ r = Kern::ThreadRawWrite(iClient, a1, ¶m, sizeof(param), iClient);
+ if (r != KErrNone)
+ PanicClientThread(r);
+ break;
+
+ case RDevUsbcScClient::EControlEndpointStatus:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlEndpointStatus"));
+ if (iValidInterface && ValidEndpoint((TInt) a1))
+ {
+ pEndpoint = iEndpoint[(TInt)a1];
+ if (pEndpoint == NULL)
+ r = KErrNotSupported;
+ else
+ {
+ param = iController->GetEndpointStatus(this, iEndpoint[(TInt)a1]->RealEpNumber());
+ r = Kern::ThreadRawWrite(iClient, a2, ¶m, sizeof(param), iClient);
+ if (r != KErrNone)
+ PanicClientThread(r);
+ }
+ }
+ else
+ {
+ if (iDeviceState != EUsbcDeviceStateConfigured)
+ r = KErrUsbDeviceNotConfigured;
+ else
+ r = KErrUsbInterfaceNotReady;
+ }
+ break;
+
+ case RDevUsbcScClient::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 RDevUsbcScClient::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 RDevUsbcScClient::EControlSendEp0StatusPacket:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSendEp0StatusPacket"));
+ iController->SendEp0StatusPacket(this);
+ break;
+
+ case RDevUsbcScClient::EControlHaltEndpoint:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlHaltEndpoint"));
+ if (iValidInterface && ValidEndpoint((TInt) a1))
+ {
+ r = iController->HaltEndpoint(this, iEndpoint[(TInt)a1]->RealEpNumber());
+ }
+ else
+ {
+ if (iDeviceState != EUsbcDeviceStateConfigured)
+ r = KErrUsbDeviceNotConfigured;
+ else
+ r = KErrUsbInterfaceNotReady;
+ }
+ break;
+
+ case RDevUsbcScClient::EControlClearHaltEndpoint:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlClearHaltEndpoint"));
+ if (iValidInterface && ValidEndpoint((TInt) a1))
+ {
+ r = iController->ClearHaltEndpoint(this, iEndpoint[(TInt)a1]->RealEpNumber());
+ }
+ else
+ {
+ if (iDeviceState != EUsbcDeviceStateConfigured)
+ r = KErrUsbDeviceNotConfigured;
+ else
+ r = KErrUsbInterfaceNotReady;
+ }
+ break;
+
+ case RDevUsbcScClient::EControlDumpRegisters:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlDumpRegisters"));
+ iController->DumpRegisters();
+ break;
+
+ case RDevUsbcScClient::EControlReleaseDeviceControl:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlReleaseDeviceControl"));
+ iController->ReleaseDeviceControl(this);
+ iOwnsDeviceControl = EFalse;
+ break;
+
+ case RDevUsbcScClient::EControlEndpointZeroMaxPacketSizes:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlEndpointZeroMaxPacketSizes"));
+ r = iController->EndpointZeroMaxPacketSizes();
+ break;
+
+ case RDevUsbcScClient::EControlSetEndpointZeroMaxPacketSize:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetEndpointZeroMaxPacketSize"));
+ r = iController->SetEndpointZeroMaxPacketSize(reinterpret_cast<TInt>(a1));
+ break;
+
+ case RDevUsbcScClient::EControlGetEndpointZeroMaxPacketSize:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetEndpointZeroMaxPacketSize"));
+ r = iController->Ep0PacketSize();
+ break;
+
+ case RDevUsbcScClient::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 RDevUsbcScClient::EControlSetDeviceDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetDeviceDescriptor"));
+ BREAK_IF_NULL_ARG(a1,r);
+ r = iController->SetDeviceDescriptor(iClient, *((TDes8*) a1));
+ break;
+
+ case RDevUsbcScClient::EControlGetDeviceDescriptorSize:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetDeviceDescriptorSize"));
+ BREAK_IF_NULL_ARG(a1,r);
+ r = iController->GetDeviceDescriptorSize(iClient, *((TDes8*) a1));
+ break;
+
+ case RDevUsbcScClient::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 RDevUsbcScClient::EControlGetConfigurationDescriptorSize:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetConfigurationDescriptorSize"));
+ if (a1 != NULL)
+ {
+ r = iController->GetConfigurationDescriptorSize(iClient, *((TDes8*) a1));
+ }
+ else
+ r = KErrArgument;
+ break;
+
+ case RDevUsbcScClient::EControlSetConfigurationDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetConfigurationDescriptor"));
+ r = iController->SetConfigurationDescriptor(iClient, *((TDes8*) a1));
+ break;
+
+ case RDevUsbcScClient::EControlGetInterfaceDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetInterfaceDescriptor"));
+ r = iController->GetInterfaceDescriptor(iClient, this, (TInt) a1, *((TDes8*) a2));
+ break;
+
+ case RDevUsbcScClient::EControlGetInterfaceDescriptorSize:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetInterfaceDescriptorSize"));
+ r = iController->GetInterfaceDescriptorSize(iClient, this, (TInt) a1, *(TDes8*) a2);
+ break;
+
+ case RDevUsbcScClient::EControlSetInterfaceDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetInterfaceDescriptor"));
+ r = iController->SetInterfaceDescriptor(iClient, this, (TInt) a1, *((TDes8*) a2));
+ break;
+
+ case RDevUsbcScClient::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 = (ep<0)?ep:iController->GetEndpointDescriptor(iClient, this, epInfo.iSetting,
+ ep, *(TDes8*) epInfo.iArg);
+ break;
+
+ case RDevUsbcScClient::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 RDevUsbcScClient::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 RDevUsbcScClient::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 RDevUsbcScClient::EControlSetDeviceQualifierDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetDeviceQualifierDescriptor"));
+ BREAK_IF_NULL_ARG(a1,r);
+ r = iController->SetDeviceQualifierDescriptor(iClient, *((TDes8*) a1));
+ break;
+
+ case RDevUsbcScClient::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 RDevUsbcScClient::EControlSetOtherSpeedConfigurationDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetOtherSpeedConfigurationDescriptor"));
+ r = iController->SetOtherSpeedConfigurationDescriptor(iClient, *((TDes8*) a1));
+ break;
+
+
+ case RDevUsbcScClient::EControlGetCSInterfaceDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetCSInterfaceDescriptor"));
+ r = iController->GetCSInterfaceDescriptorBlock(iClient, this, (TInt) a1, *((TDes8*) a2));
+ break;
+
+ case RDevUsbcScClient::EControlGetCSInterfaceDescriptorSize:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetCSInterfaceDescriptorSize"));
+ r = iController->GetCSInterfaceDescriptorBlockSize(iClient, this, (TInt) a1, *(TDes8*) a2);
+ break;
+
+ case RDevUsbcScClient::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 RDevUsbcScClient::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 RDevUsbcScClient::EControlSignalRemoteWakeup:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSignalRemoteWakeup"));
+ r = iController->SignalRemoteWakeup();
+ break;
+
+ case RDevUsbcScClient::EControlDeviceDisconnectFromHost:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlDeviceDisconnectFromHost"));
+ r = iController->UsbDisconnect();
+ break;
+
+ case RDevUsbcScClient::EControlDeviceConnectToHost:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlDeviceConnectToHost"));
+ r = iController->UsbConnect();
+ break;
+
+ case RDevUsbcScClient::EControlDevicePowerUpUdc:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlDevicePowerUpUdc"));
+ r = iController->PowerUpUdc();
+ break;
+
+ case RDevUsbcScClient::EControlSetDeviceControl:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetDeviceControl"));
+ r = iController->SetDeviceControl(this);
+ if (r == KErrNone)
+ {
+ iOwnsDeviceControl = ETrue;
+ if (iEp0Endpoint == NULL)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetDeviceControl"));
+ r = SetupEp0();
+ if (r != KErrNone)
+ {
+ __KTRACE_OPT(KPANIC, Kern::Printf(" Error: SetupEp0() failed"));
+ iController->ReleaseDeviceControl(this);
+ iOwnsDeviceControl=EFalse;
+ DestroyEp0();
+ }
+ }
+ }
+ else
+ r = KErrInUse;
+ break;
+
+ case RDevUsbcScClient::EControlCurrentlyUsingHighSpeed:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlCurrentlyUsingHighSpeed"));
+ r = iController->CurrentlyUsingHighSpeed();
+ break;
+
+ case RDevUsbcScClient::EControlSetInterface:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetInterface"));
+ r = Kern::ThreadRawRead(iClient, a2, &ifcInfo, sizeof(ifcInfo));
+ if (r != KErrNone)
+ PanicClientThread(r);
+ r = SetInterface((TInt) a1, &ifcInfo);
+ break;
+
+ case RDevUsbcScClient::EControlReleaseInterface:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlReleaseInterface"));
+ if (!iRealizeCalled)
+ {
+ 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."));
+ }
+ }
+ else
+ r = KErrUsbAlreadyRealized;
+ break;
+
+ case RDevUsbcScClient::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 RDevUsbcScClient::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 RDevUsbcScClient::EControlGetStringDescriptorLangId:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetStringDescriptorLangId"));
+ r = iController->GetStringDescriptorLangId(iClient, *((TDes8*) a1));
+ break;
+
+ case RDevUsbcScClient::EControlSetStringDescriptorLangId:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetStringDescriptorLangId"));
+ r = iController->SetStringDescriptorLangId(reinterpret_cast<TUint>(a1));
+ break;
+
+ case RDevUsbcScClient::EControlGetManufacturerStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetManufacturerStringDescriptor"));
+ r = iController->GetManufacturerStringDescriptor(iClient, *((TPtr8*) a1));
+ break;
+
+ case RDevUsbcScClient::EControlSetManufacturerStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetManufacturerStringDescriptor"));
+ r = iController->SetManufacturerStringDescriptor(iClient, *((TPtr8*) a1));
+ break;
+
+ case RDevUsbcScClient::EControlRemoveManufacturerStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveManufacturerStringDescriptor"));
+ r = iController->RemoveManufacturerStringDescriptor();
+ break;
+
+ case RDevUsbcScClient::EControlGetProductStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetProductStringDescriptor"));
+ r = iController->GetProductStringDescriptor(iClient, *((TPtr8*) a1));
+ break;
+
+ case RDevUsbcScClient::EControlSetProductStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetProductStringDescriptor"));
+ r = iController->SetProductStringDescriptor(iClient, *((TPtr8*) a1));
+ break;
+
+ case RDevUsbcScClient::EControlRemoveProductStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveProductStringDescriptor"));
+ r = iController->RemoveProductStringDescriptor();
+ break;
+
+ case RDevUsbcScClient::EControlGetSerialNumberStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetSerialNumberStringDescriptor"));
+ r = iController->GetSerialNumberStringDescriptor(iClient, *((TPtr8*) a1));
+ break;
+
+ case RDevUsbcScClient::EControlSetSerialNumberStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetSerialNumberStringDescriptor"));
+ r = iController->SetSerialNumberStringDescriptor(iClient, *((TPtr8*) a1));
+ break;
+
+ case RDevUsbcScClient::EControlRemoveSerialNumberStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveSerialNumberStringDescriptor"));
+ r = iController->RemoveSerialNumberStringDescriptor();
+ break;
+
+ case RDevUsbcScClient::EControlGetConfigurationStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetConfigurationStringDescriptor"));
+ r = iController->GetConfigurationStringDescriptor(iClient, *((TPtr8*) a1));
+ break;
+
+ case RDevUsbcScClient::EControlSetConfigurationStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetConfigurationStringDescriptor"));
+ r = iController->SetConfigurationStringDescriptor(iClient, *((TPtr8*) a1));
+ break;
+
+ case RDevUsbcScClient::EControlRemoveConfigurationStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveConfigurationStringDescriptor"));
+ r = iController->RemoveConfigurationStringDescriptor();
+ break;
+
+ case RDevUsbcScClient::EControlGetStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetStringDescriptor"));
+ r = iController->GetStringDescriptor(iClient, (TUint8) (TInt) a1, *((TPtr8*) a2));
+ break;
+
+ case RDevUsbcScClient::EControlSetStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetStringDescriptor"));
+ r = iController->SetStringDescriptor(iClient, (TUint8) (TInt) a1, *((TPtr8*) a2));
+ break;
+
+ case RDevUsbcScClient::EControlRemoveStringDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveStringDescriptor"));
+ r = iController->RemoveStringDescriptor((TUint8) (TInt) a1);
+ break;
+
+ case RDevUsbcScClient::EControlAllocateEndpointResource:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlAllocateEndpointResource"));
+ epRes = (TUsbcEndpointResource)((TInt) a2);
+ TInt realEp=-1;
+ r = GetRealEpForEpResource((TInt)a1, realEp);
+ if (r==KErrNone)
+ r = iController->AllocateEndpointResource(this, realEp, epRes);
+ break;
+ }
+ case RDevUsbcScClient::EControlDeAllocateEndpointResource:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlDeAllocateEndpointResource"));
+ epRes = (TUsbcEndpointResource)((TInt) a2);
+ TInt realEp=-1;
+ r = GetRealEpForEpResource((TInt)a1, realEp);
+ if (r==KErrNone)
+ r = iController->DeAllocateEndpointResource(this, realEp, epRes);
+ break;
+ }
+ case RDevUsbcScClient::EControlQueryEndpointResourceUse:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlQueryEndpointResourceUse"));
+ epRes = (TUsbcEndpointResource)((TInt) a2);
+ TInt realEp=-1;
+ r = GetRealEpForEpResource((TInt)a1, realEp);
+ if (r==KErrNone)
+ r = iController->QueryEndpointResource(this, realEp, epRes);
+ break;
+ }
+ case RDevUsbcScClient::EControlSetOtgDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlSetOtgDescriptor"));
+ r = iController->SetOtgDescriptor(iClient, *((const TDesC8*)a1));
+ break;
+
+ case RDevUsbcScClient::EControlGetOtgDescriptor:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetOtgDescriptor"));
+ r = iController->GetOtgDescriptor(iClient, *((TDes8*)a1));
+ break;
+
+ case RDevUsbcScClient::EControlGetOtgFeatures:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlGetOtgFeatures"));
+ r = iController->GetOtgFeatures(iClient, *((TDes8*)a1));
+ break;
+
+ case RDevUsbcScClient::EControlRealizeInterface:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlRealizeInterface"));
+ r = RealizeInterface();
+ break;
+ case RDevUsbcScClient::EControlStartNextInAlternateSetting:
+ __KTRACE_OPT(KUSB, Kern::Printf("EControlStartNextInAlternateSetting"));
+ r = StartNextInAlternateSetting();
+ break;
+
+ default:
+ __KTRACE_OPT(KUSB, Kern::Printf("Function code not supported"));
+ r = KErrNotSupported;
+ }
+
+ return r;
+ }
+// end DoControl.
+
+
+
+//
+// Overriding DObject virtual
+//
+TInt DLddUsbcScChannel::RequestUserHandle(DThread* aThread, TOwnerType /*aType*/)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcScChannel::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;
+ }
+ }
+
+inline TInt DLddUsbcScChannel::GetRealEpForEpResource(TInt aEndpoint, TInt& aRealEp)
+ {
+ if (iEndpoint) // if we've enumerated at least once, proceed as normal.
+ {
+ if (aEndpoint <= iNumberOfEndpoints && aEndpoint >= 0)
+ {
+ aRealEp=iEndpoint[aEndpoint]->RealEpNumber();
+ return KErrNone;
+ }
+ }
+ else // Assume alternate setting 0.
+ {
+ if (iAlternateSettingList) // Check it has been set up.
+ {
+ TUsbcScAlternateSetting* alt = iAlternateSettingList->iHead;
+ if (alt && (aEndpoint <= alt->iNumberOfEndpoints && aEndpoint >= 0))
+ {
+ aRealEp= alt->iEndpoint[aEndpoint]->RealEpNumber();
+ return KErrNone;
+ }
+ }
+ }
+ return KErrUsbDeviceNotConfigured;
+ }
+
+
+TUsbcEndpointInfoArray::TUsbcEndpointInfoArray(const TUsbcScEndpointInfo* aData, TInt aDataSize)
+ {
+ iType = EUsbcScEndpointInfo;
+ iData = (TUint8*) aData;
+ if (aDataSize>0)
+ iDataSize = aDataSize;
+ else
+ iDataSize = sizeof(TUsbcScEndpointInfo);
+ }
+
+
+//
+// SetInterface
+//
+// Called from DoControl. Sets the configuration of a given Interface. // Needs changing
+// All interfaces must be configured before one can be used.
+//
+
+TInt DLddUsbcScChannel::SetInterface(TInt aInterfaceNumber, TUsbcScIfcInfo* aInfoBuf)
+ {
+ // Copy interface description.
+
+ if (iRealizeCalled)
+ return KErrUsbAlreadyRealized;
+
+ if (!iAlternateSettingList)
+ {
+ iAlternateSettingList = new TUsbcScAlternateSettingList;
+ if (iAlternateSettingList==NULL)
+ {
+ return KErrNoMemory;
+ }
+ }
+
+ // Read descriptor in
+ TUsbcScInterfaceInfoBuf ifc_info_buf;
+ TUsbcScInterfaceInfoBuf* const ifc_info_buf_ptr = aInfoBuf->iInterfaceData;
+ const TInt srcLen = Kern::ThreadGetDesLength(iClient, ifc_info_buf_ptr);
+
+ __KTRACE_OPT(KUSB, Kern::Printf("SetInterface srcLen = %d len = %d", srcLen, ifc_info_buf.Length() ));
+
+ 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);
+ }
+
+ // The list of endpoints is within the interface info.
+ TUsbcScEndpointInfo* pEndpointData = ifc_info_buf().iEndpointData;
+
+ const TInt num_endpoints = ifc_info_buf().iTotalEndpointsUsed;
+ __KTRACE_OPT(KUSB, Kern::Printf("SetInterface num_endpoints=%d", num_endpoints));
+ if (num_endpoints>KMaxEndpointsPerClient)
+ return KErrOverflow;
+
+
+ // Initialize real ep numbers list.
+ TInt i;
+ TInt real_ep_numbers[KMaxEndpointsPerClient+1]; // range 1->KMaxEndpointsPerClient (0 not used)
+ for (i=0; i<=KMaxEndpointsPerClient; i++)
+ real_ep_numbers[i] = -1;
+
+
+ // See if PIL will accept this interface
+ __KTRACE_OPT(KUSB, Kern::Printf("SetInterface Calling controller"));
+ TUsbcEndpointInfoArray endpointData = TUsbcEndpointInfoArray(ifc_info_buf().iEndpointData);
+
+ r = iController->SetInterface(this,
+ iClient,
+ aInterfaceNumber,
+ ifc_info_buf().iClass,
+ aInfoBuf->iString,
+ (TInt) ifc_info_buf().iTotalEndpointsUsed,
+ endpointData,
+ &real_ep_numbers[0],
+ 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;
+ }
+
+ // create alternate setting record
+ TUsbcScAlternateSetting* alternateSettingListRec = new TUsbcScAlternateSetting;
+ if (!alternateSettingListRec)
+ {
+ r = KErrNoMemory;
+ goto ReleaseInterface;
+ }
+
+ // other endpoints
+ for (TInt i = 1; i <= num_endpoints; i++, pEndpointData++)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("SetInterface for ep=%d", i));
+
+ if ((pEndpointData->iType==KUsbEpTypeControl)
+ || (pEndpointData->iDir != KUsbEpDirIn && pEndpointData->iDir != KUsbEpDirOut)
+ || (pEndpointData->iSize > 1024) || (pEndpointData->iSize<=0))
+ {
+ r = KErrUsbBadEndpoint;
+ goto CleanUp;
+ }
+ // Check data
+
+ TUint* bufferSize = &(pEndpointData->iBufferSize);
+ if (*bufferSize==0)
+ *bufferSize= KUsbcScDefaultBufferSize;
+
+ TInt pageSize = Kern::RoundToPageSize(1);
+ // Round buffersize up to nearest pagesize.
+ *bufferSize = (*bufferSize+pageSize-1) & ~(pageSize-1);
+
+ TUsbcScEndpoint* ep = new TUsbcScEndpoint(this, iController, pEndpointData, i);
+ alternateSettingListRec->iEndpoint[i] = ep;
+ if (!ep)
+ {
+ r = KErrNoMemory;
+ goto CleanUp;
+ }
+ if (ep->Construct() != KErrNone)
+ {
+ r = KErrNoMemory;
+ goto CleanUp;
+ }
+
+
+ __KTRACE_OPT(KUSB, Kern::Printf("SetInterface for ep=%d rec=0x%08x ep==0x%08x",
+ i, alternateSettingListRec, ep));
+ }
+
+ if (iAlternateSettingList->iHead)
+ {
+ iAlternateSettingList->iTail->iNext = alternateSettingListRec;
+ alternateSettingListRec->iPrevious = iAlternateSettingList->iTail;
+ iAlternateSettingList->iTail = alternateSettingListRec;
+ }
+ else
+ {
+ iAlternateSettingList->iHead = alternateSettingListRec;
+ iAlternateSettingList->iTail = alternateSettingListRec;
+ }
+
+ alternateSettingListRec->iNext = NULL;
+ 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]);
+ }
+
+ return KErrNone;
+
+ CleanUp:
+ delete alternateSettingListRec;
+ //Fall Through
+
+ ReleaseInterface:
+#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;
+ }
+// end SetInterface
+
+
+
+#ifdef _DEBUG
+void RealizeInterface_Dump(TUint* aMem)
+ {
+ TUint *mem= NULL;
+ __KTRACE_OPT(KUSB, mem = aMem);
+ if (mem!=NULL)
+ {
+ TInt j;
+ Kern::Printf("Final chunk header State:");
+ for (j=0; j<30; j+=8)
+ Kern::Printf("%2x: %8x %8x %8x %8x %8x %8x %8x %8x", j, mem[j], mem[j+1], mem[j+2], mem[j+3], mem[j+4], mem[j+5], mem[j+6], mem[j+7] );
+ };
+ };
+#endif
+
+
+/*
+Chunk Created, filled with structure, and passed back to userside.
+*/
+TInt DLddUsbcScChannel::RealizeInterface(void)
+{
+ if (iRealizeCalled)
+ return KErrUsbAlreadyRealized;
+
+ TRealizeInfo bufInfo;
+
+ TInt errorOrChunk = KErrNone;
+ TBool openedCS = EFalse;
+ TInt offset =0;
+
+ // Start by creating a temporary scratchpad for endpoint calculations.
+ bufInfo.Init(iAlternateSettingList);
+
+ // Fill in our scratchpad with all the required endpoints, sorting them
+ // in order of size required.
+ errorOrChunk = bufInfo.CopyAndSortEndpoints();
+ if (errorOrChunk!=KErrNone)
+ {
+ goto realize_end;
+ }
+
+ // We now have endpoints sorted in order of size for each altsetting.
+ // The very largest for each endpoint will share the first buffer, and all of
+ // the second largest ends points will share the second buffer, and so on.
+ // Find the highest buffer size for each row, to determine the buffer size,
+ // and keep a total of total space needed.
+ bufInfo.CalcBuffSizes();
+
+ // We now have the max sizes wanted for each endpoint buffer.
+ // we also have to total size for all endpoints.
+ // and finally we have the total number of buffers.
+
+ // Add on size for header, then add on size for guard pages.
+ bufInfo.iTotalSize+= KHeaderSize + bufInfo.iTotalBuffers * KGuardSize;
+
+ // Create shared Chunk . . . . . . . . . .
+ if (iChunkInfo==NULL)
+ {
+ NKern::ThreadEnterCS();
+ openedCS = ETrue;
+ errorOrChunk = TUsbcScChunkInfo::New(iChunkInfo, bufInfo.iTotalSize, (DLogicalDevice*) iDevice);
+ if (errorOrChunk!=KErrNone)
+ {
+ goto realize_end;
+ }
+ }
+ else
+ {
+ // As of writing, the was no way for iChunk to be anything other then NULL.
+ // You cannot 'unrealise' and iChunk cannot be set any other way.
+ Kern::Fault("DLddUsbcScChannel::RealizeInterface", __LINE__);
+ }
+
+ // Populate the shared chunk . . . . . . .
+
+
+ // First create chunk header.
+ errorOrChunk = iChunkInfo->ChunkAlloc(offset, KHeaderSize);
+ if (errorOrChunk!=KErrNone)
+ {
+ if (errorOrChunk==-KErrNoMemory)
+ errorOrChunk=KErrNoMemory;
+ goto realize_end;
+ }
+
+
+ offset+=KHeaderSize + KGuardSize; // Also any more for EP0?
+
+ // Next, lay out the geometry of the chunk header.
+
+ bufInfo.LayoutChunkHeader(iChunkInfo);
+
+
+ { // Scope ep0Size
+ TInt ep0Size=0;
+
+ // Create K-side buffer table
+ if (!iBuffers)
+ iBuffers = (TUsbcScBuffer *) Kern::AllocZ(sizeof(TUsbcScBuffer) * (bufInfo.iTotalBuffers+2)); // +2 is for ep0.
+ if (!iBuffers)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: Error: Alloc iBufers failed!"));
+ errorOrChunk = KErrNoMemory;
+ goto realize_end;
+ }
+
+
+ errorOrChunk = SetupEp0();
+ if (errorOrChunk)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: SetupEp0 . ERROR %d",errorOrChunk));
+ goto realize_end;
+ }
+
+ ep0Size = iEp0Endpoint->EndpointInfo()->iSize;
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: Setup EP0. max packet size %d", ep0Size));
+
+ // Create EP0 buffers
+ iEP0OutBuff=bufInfo.iTotalBuffers;
+ errorOrChunk = iBuffers[iEP0OutBuff].Construct(KUsbcScBiOut, this, KUsbScEP0OutBufPos, KUsbScEP0OutBufEnd, ep0Size, ep0Size, ep0Size);
+ if (errorOrChunk)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: Setup EP0 Out. ERROR %d",errorOrChunk));
+ goto realize_end;
+ }
+
+ iBuffers[iEP0OutBuff].CreateChunkBufferHeader();
+ iBuffers[iEP0OutBuff].iCallback = iEp0Endpoint->iRequestCallbackInfo;
+ ((TUsbcScBufferRecord*) &(
+ bufInfo.iChunkStuct->iBufferOffset[KUsbcScEp0OutBuff*sizeof(TUsbcScBufferRecord)]
+ )) ->Set(KUsbScEP0OutBufPos, KUsbScEP0OutBufEnd);
+
+
+ iEP0InBuff=bufInfo.iTotalBuffers+1;
+ errorOrChunk = iBuffers[iEP0InBuff].Construct( KUsbcScBiIn , this, KUsbScEP0InBufPos , KUsbScEP0InBufEnd , ep0Size, ep0Size, ep0Size);
+ if (errorOrChunk)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: Setup EP0 In. ERROR %d",errorOrChunk));
+ goto realize_end;
+ }
+
+ iBuffers[iEP0InBuff].iCallback = iEp0Endpoint->iRequestCallbackInfo;
+
+ ((TUsbcScBufferRecord*) &(
+ bufInfo.iChunkStuct->iBufferOffset[KUsbcScEp0InBuff*sizeof(TUsbcScBufferRecord)]
+ ))->Set(KUsbScEP0InBufPos, KUsbScEP0InBufEnd);
+
+
+ } // end ep0Size scope
+
+ // Create resources and tables. . . . . .
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: Create resources tables"));
+
+ { // scope of bufNum
+ // For each EP buffer
+ TInt buffNum=0;
+ TInt buffMinSize;
+ TInt endpointNumber;
+ TUsbcScEndpoint* endpointRecord;
+ TInt endpoint;
+ TInt inout;
+ TEndpointSortBufs* bufsd;
+ TUsbcScHdrEndpointRecord* epRecord;
+ for (endpoint=0; endpoint<bufInfo.iMaxEndpoints; endpoint++) // endpoint = buf row.
+ {
+ for (inout=KUsbcScIn; inout<KUsbcScDirections; inout++)
+ {
+ buffMinSize = KUsbSc_BigBuff_MinimumRamRun;
+
+ TInt needed = bufInfo.iBufs[inout].iSizes[endpoint];
+ if (needed)
+ {
+ TInt bufStart = offset;
+
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: buf row:%d inout %d, iBufferOffset[%d+2]=%x",endpoint, inout, buffNum, bufStart));
+
+ bufsd = &(bufInfo.iBufs[inout]);
+ // and then point all endpoints that use it, towards it.
+ TInt altSetting;
+ TUint maxReadSize = ~0;
+ for (altSetting=0; altSetting < bufInfo.iAltSettings; altSetting++)
+ {
+ endpointRecord =bufsd->iEp[altSetting*bufInfo.iMaxEndpoints + endpoint];
+ if (endpointRecord)
+ {
+ endpointNumber = endpointRecord->EpNumber();
+ endpointRecord->SetBuffer(&iBuffers[buffNum]);
+
+ epRecord = (TUsbcScHdrEndpointRecord*) &iChunkInfo->iChunkMem[
+ (bufInfo.iAltSettingsTbl->iAltTableOffset[altSetting]) // i.e. Just after altSettingsTbl
+ +sizeof(TInt) // after number of endpoints field
+ +(endpointNumber-1)*sizeof(TUsbcScHdrEndpointRecord)
+ ];
+ epRecord->iBufferNo = (TUint8) buffNum;
+
+ TInt epType=(endpointRecord->EndpointInfo()->iType);
+ epType= (epType& KUsbEpTypeControl)?KUsbScHdrEpTypeControl:
+ (epType& KUsbEpTypeIsochronous)?KUsbScHdrEpTypeIsochronous:
+ (epType& KUsbEpTypeBulk)?KUsbScHdrEpTypeBulk:
+ (epType& KUsbEpTypeInterrupt)?KUsbScHdrEpTypeInterrupt:KUsbScHdrEpTypeUnknown;
+
+ epRecord->iType = (inout+1) | (epType<<2);
+
+ if (endpointRecord->EndpointInfo()->iReadSize)
+ maxReadSize = (maxReadSize <= endpointRecord->EndpointInfo()->iReadSize) ? maxReadSize : endpointRecord->EndpointInfo()->iReadSize;
+
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: endpointNum %d in altSetting %d, alt table @ %d",
+ endpointNumber, altSetting,bufInfo.iAltSettingsTbl->iAltTableOffset[altSetting]));
+ }
+ else
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: endpointNum NA in altSetting %d", altSetting));
+ }
+
+ } // end for
+
+
+ // Alloc memory for buffer.
+ TInt grabSize = needed;
+ // Generally, a buffer fragmented into smaller memory regions will reduce the efficiency
+ // of reading or writing data, and so avoiding the allocation of very small sections
+ // is advantageous.
+ // However, if only a small amount is being allocated to start with, it is likely
+ // smaller amounts of data are to be sent (reducing this advantage), and 1 memory page
+ // is a much bigger proportion of the buffer, and so more worth allocating individually.
+
+ TInt minimumGrab;
+ if (needed<KUsbScBigBuffIs)
+ {
+ minimumGrab=Kern::RoundToPageSize(1);
+ buffMinSize = KUsbSc_SmallBuff_MinimumRamRun; // 1k
+ }
+ else
+ {
+ minimumGrab = buffMinSize+Kern::RoundToPageSize(1);
+ }
+
+ // Grab required memory, in bits as big as possible, down to the minimum size.
+ while (needed >= minimumGrab)
+ {
+ TInt r;
+ r = iChunkInfo->ChunkAlloc(offset, grabSize);
+ if (r==KErrNone)
+ {
+ offset+=grabSize;
+ needed-=grabSize;
+ }
+ else
+ {
+ if (r==-KErrNoMemory)
+ {
+ grabSize>>=1;
+ }
+ if ((grabSize<minimumGrab) || (r!=-KErrNoMemory))
+ {
+ errorOrChunk = r;
+ goto realize_end;
+ }
+ }
+ } // end while needed
+
+ // Initialize buffer
+ iBuffers[buffNum].Construct(inout, this, bufStart, offset, buffMinSize, 0, maxReadSize);
+ iBuffers[buffNum].CreateChunkBufferHeader();
+ ((TUsbcScBufferRecord*) &(
+ bufInfo.iChunkStuct->iBufferOffset[(buffNum+2)*sizeof(TUsbcScBufferRecord)]
+ ))->Set(bufStart, offset);
+
+
+ // inc pointers for next buffer
+ buffNum++;
+ offset+=KGuardSize;
+ } // end if needed
+
+ } // end for inout
+ } // end for each buffer
+ } // scope of bufNum
+
+#ifdef _DEBUG
+ RealizeInterface_Dump((TUint*) iChunkInfo->iChunkMem); // Debug only tracing
+#endif
+
+realize_end:
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: cleanup. Err=%d", errorOrChunk));
+ // Here we clean up after either success, or after bailing out early.
+
+ bufInfo.Free();
+
+ if (iChunkInfo)
+ {
+ if (errorOrChunk==KErrNone)
+ {
+ // Everything is looking good - create RChunk for Userside.
+ errorOrChunk = Kern::MakeHandleAndOpen(iClient, iChunkInfo->iChunk);
+ iRealizeCalled = (errorOrChunk>=0);
+ } // endif errorOrChunk
+
+ if (errorOrChunk<0) // If error, destroy the chunk.
+ {
+ iChunkInfo->Close();
+ // ChunkInfo will delete itself with DFC, but the pointer here is no longer needed.
+ iChunkInfo=NULL;
+
+ // Destroy iBuffers
+ if (iBuffers)
+ {
+ TInt i;
+ for (i=0; i<(iNumBuffers+2); i++)
+ {
+ iBuffers[i].iStatusList.Destroy();
+ }
+ Kern::Free(iBuffers);
+ iBuffers=NULL;
+ }
+
+ }
+ else
+ {
+ iNumBuffers = bufInfo.iTotalBuffers;
+ iValidInterface = ETrue; // Let the games commence!
+ }
+
+ } // endif iChunkInfo
+ if (openedCS)
+ NKern::ThreadLeaveCS();
+
+ __KTRACE_OPT(KUSB, Kern::Printf("Realize: returning %x (%d)", errorOrChunk, errorOrChunk));
+ return errorOrChunk;
+} // End RealizeInterface
+
+
+//
+// DestroyAllInterfaces
+//
+
+void DLddUsbcScChannel::DestroyAllInterfaces()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcScChannel::DestroyAllInterfaces"));
+ // Removes all interfaces
+ if (iAlternateSettingList)
+ {
+ if (iAlternateSettingList->iHead != NULL)
+ {
+ TUsbcScAlternateSetting* alternateSettingListRec = iAlternateSettingList->iTail;
+ while (alternateSettingListRec)
+ {
+ iAlternateSettingList->iTail = alternateSettingListRec->iPrevious;
+ // If this contains NULL now that is only possible if the record to be deleted was at the head
+ __KTRACE_OPT(KUSB, Kern::Printf("Release interface %d \n", alternateSettingListRec->iSetting));
+ iController->ReleaseInterface(this, alternateSettingListRec->iSetting);
+ delete alternateSettingListRec;
+ if (iAlternateSettingList->iTail == NULL) //No more interfaces left
+ break;
+ else
+ {
+ iAlternateSettingList->iTail->iNext = NULL;
+ alternateSettingListRec = iAlternateSettingList->iTail;
+ }
+ }
+ }
+ delete iAlternateSettingList;
+ }
+
+ iNumberOfEndpoints = 0;
+ iAlternateSettingList = NULL;
+ iValidInterface = EFalse;
+
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcScChannel::DestroyAllInterfaces done"));
+ }
+
+
+
+
+
+//
+// DestroyInterface
+//
+
+void DLddUsbcScChannel::DestroyInterface(TUint aInterfaceNumber)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcScChannel::DestroyInterface \n"));
+
+ if (iAlternateSetting == aInterfaceNumber)
+ {
+ ResetInterface(KErrUsbInterfaceNotReady);
+ iValidInterface = EFalse;
+ iNumberOfEndpoints = 0;
+ }
+ if (iAlternateSettingList)
+ {
+ TUsbcScAlternateSetting* alternateSettingListRec = iAlternateSettingList->iTail;
+ TUsbcScAlternateSetting* alternateSettingListRecFound = NULL;
+ while (alternateSettingListRec)
+ {
+ if (alternateSettingListRec->iSetting == aInterfaceNumber)
+ {
+ alternateSettingListRecFound = alternateSettingListRec;
+ if (alternateSettingListRec->iPrevious == NULL) //Interface is at HEAD OF List, Should only be if Interface is also at Tail of list
+ {
+ iAlternateSettingList->iHead = alternateSettingListRec->iNext; // Should be NULL
+ if (alternateSettingListRec->iNext)
+ iAlternateSettingList->iHead->iPrevious = NULL;
+ }
+ else if (alternateSettingListRec->iNext == NULL) //Interface is at TAIL OF List
+ {
+ iAlternateSettingList->iTail = alternateSettingListRecFound->iPrevious;
+ iAlternateSettingList->iTail->iNext = NULL;
+ }
+ else //Somewhere in the middle (would not expect this in normal operation, but here for completeness)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcScChannel::DestroyInterface Middle interface!\n"));
+ alternateSettingListRec->iPrevious->iNext = alternateSettingListRec->iNext;
+ alternateSettingListRec->iNext->iPrevious = alternateSettingListRec->iPrevious;
+ }
+
+ delete alternateSettingListRecFound;
+ break;
+ }
+ alternateSettingListRec = alternateSettingListRec->iPrevious;
+ }
+ }
+ }
+
+//
+// SetupEp0
+//
+
+TInt DLddUsbcScChannel::SetupEp0()
+ {
+ __ASSERT_ALWAYS(iEp0Endpoint==NULL, Kern::Fault("DLddUsbcScChannel::SetupEp0", __LINE__));
+
+ TUsbcScEndpointInfo ep0Info = TUsbcScEndpointInfo(KUsbEpTypeControl, KUsbEpDirBidirect);
+ ep0Info.iSize = iController->Ep0PacketSize();
+
+ TUsbcScEndpoint* ep0 = new TUsbcScEndpoint(this, iController, &ep0Info, 0);
+ if (ep0 == NULL)
+ {
+ return KErrNoMemory;
+ }
+
+ TInt r = ep0->Construct();
+ if (r != KErrNone)
+ {
+ delete ep0;
+ return KErrNoMemory;
+ }
+
+ ep0->SetRealEpNumber(0);
+ ep0->SetBuffer(NULL); // Cannot find it this way.
+
+ iEp0Endpoint = ep0;
+ return KErrNone;
+ }
+
+//
+// DestroyEp0
+//
+
+void DLddUsbcScChannel::DestroyEp0()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" DLddUsbcScChannel::DestroyEp0"));
+ delete iEp0Endpoint;
+ iEp0Endpoint = NULL;
+ }
+
+
+void DLddUsbcScChannel::RequestCallbackEp0(TAny* aDLddUsbcScChannel)
+ {
+ DLddUsbcScChannel* channel = (DLddUsbcScChannel*) aDLddUsbcScChannel;
+
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcScChannel::RequestCallbackEp0"));
+
+ if (channel->ChannelClosing())
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Channel Closing: Completion not accepted!"));
+ return;
+ }
+
+ switch (channel->iEp0Endpoint->iRequestCallbackInfo->iTransferDir)
+ {
+ case EControllerWrite:
+ channel->iBuffers[channel->iEP0InBuff].CompleteWrite();
+ return;
+ case EControllerRead:
+ channel->iBuffers[channel->iEP0OutBuff].CompleteRead();
+ return;
+ default:
+ Kern::Printf("DLddUsbcScChannel::RequestCallbackEp0 - Unexpected completion direction %d",channel->iEp0Endpoint->iRequestCallbackInfo->iTransferDir);
+ Kern::Fault("DLddUsbcScChannel::RequestCallbackEp0", __LINE__);
+ }
+ }
+
+
+
+
+
+
+//
+// EndpointStatusChangeCallback
+//
+
+void DLddUsbcScChannel::EndpointStatusChangeCallback(TAny* aDLddUsbcScChannel)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("EndpointStatusChangeCallback"));
+ DLddUsbcScChannel* dUsbc = (DLddUsbcScChannel*) aDLddUsbcScChannel;
+ if (dUsbc->iChannelClosing)
+ return;
+ TUint endpointState = dUsbc->iEndpointStatusCallbackInfo.State();
+ const TInt reqNo = (TInt) RDevUsbcScClient::ERequestEndpointStatusNotify;
+ if (dUsbc->iRequestStatus[reqNo])
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("EndpointStatusChangeCallback Notify status"));
+ DThread* client = dUsbc->iClient;
+ // set client descriptor length to zero
+ TInt r = Kern::ThreadRawWrite(client, dUsbc->iEndpointStatusChangePtr, &endpointState,
+ sizeof(TUint), client);
+ if (r != KErrNone)
+ dUsbc->PanicClientThread(r);
+ Kern::RequestComplete(dUsbc->iClient, dUsbc->iRequestStatus[reqNo], r);
+ dUsbc->iEndpointStatusChangePtr = NULL;
+ }
+ }
+
+
+//
+// StatusChangeCallback
+//
+
+void DLddUsbcScChannel::StatusChangeCallback(TAny* aDLddUsbcScChannel)
+ {
+ DLddUsbcScChannel* dUsbc = (DLddUsbcScChannel*) aDLddUsbcScChannel;
+ if (dUsbc->iChannelClosing)
+ return;
+
+ TUsbcDeviceState deviceState;
+ TInt i;
+ for (i = 0;
+ (i < KUsbcDeviceStateRequests) && ((deviceState = dUsbc->iStatusCallbackInfo.State(i)) != EUsbcNoState);
+ ++i)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("StatusChangeCallBack status=%d", deviceState));
+ if (deviceState & KUsbAlternateSetting)
+ {
+ dUsbc->ProcessAlternateSetting(deviceState);
+ }
+ else
+ {
+ dUsbc->ProcessDeviceState(deviceState);
+ // Send Status to EP0 buffer.
+ dUsbc->iBuffers[dUsbc->iEP0OutBuff].SendEp0StatusPacket(deviceState);
+ }
+
+ // Only queue if userside is interested
+ if (dUsbc->iDeviceStatusNeeded)
+ {
+ dUsbc->iStatusFifo->AddStatusToQueue(deviceState);
+ const TInt reqNo = (TInt) RDevUsbcScClient::ERequestAlternateDeviceStatusNotify;
+ if (dUsbc->AlternateDeviceStateTestComplete())
+ Kern::RequestComplete(dUsbc->iClient, dUsbc->iRequestStatus[reqNo], 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 DLddUsbcScChannel::OtgFeatureChangeCallback(TAny* aDLddUsbcScChannel)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("OtgFeatureChangeCallback"));
+ DLddUsbcScChannel* dUsbc = (DLddUsbcScChannel*) aDLddUsbcScChannel;
+ if (dUsbc->iChannelClosing)
+ return;
+
+ TUint8 features;
+ // No return value check. Assume OTG always supported here
+ dUsbc->iController->GetCurrentOtgFeatures(features);
+
+ const TInt reqNo = (TInt) RDevUsbcScClient::ERequestOtgFeaturesNotify;
+ if (dUsbc->iRequestStatus[reqNo])
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("OtgFeatureChangeCallback Notify status"));
+ TInt r = Kern::ThreadRawWrite(dUsbc->iClient, dUsbc->iOtgFeatureChangePtr,
+ &features, sizeof(TUint8), dUsbc->iClient);
+ if (r != KErrNone)
+ dUsbc->PanicClientThread(r);
+ Kern::RequestComplete(dUsbc->iClient, dUsbc->iRequestStatus[reqNo], r);
+ dUsbc->iOtgFeatureChangePtr = NULL;
+ }
+ }
+
+
+//
+// SelectAlternateSetting
+//
+
+TInt DLddUsbcScChannel::SelectAlternateSetting(TUint aAlternateSetting)
+ {
+ TUsbcScEndpoint* ep;
+
+ // First, find the alt setting record, which corresponds to the alt setting number.
+ TUsbcScAlternateSetting* alternateSettingListRec;
+ if(iAlternateSettingList)
+ {
+ for (alternateSettingListRec = iAlternateSettingList->iHead; alternateSettingListRec; alternateSettingListRec = alternateSettingListRec->iNext)
+ if (alternateSettingListRec->iSetting == aAlternateSetting)
+ {
+ // Record has been located.
+
+ // Update current ep setting vars
+ iEndpoint = alternateSettingListRec->iEndpoint;
+ iNumberOfEndpoints = alternateSettingListRec->iNumberOfEndpoints;
+
+
+
+ // Reset buffers for new ep set
+ for (TInt i = 1; i <= KMaxEndpointsPerClient; i++)
+ {
+ ep = alternateSettingListRec->iEndpoint[i];
+ if (ep!=NULL)
+ ep->StartBuffer(); // Buffer::StartEndpoint(...) sets the necessary parameters to the buffer, for use for a perticular endpoint.
+ }
+
+ return KErrNone;
+ }
+ }
+ return KErrGeneral;
+ }
+
+/* The user calls this to move into the next alternate setting. After this call, it is assumed the user wants to
+Transmit using endpoints belonging to this alternate Setting. Writes to the IN endpoints will be allowed until
+the host changed the alternate setting again
+Returns a 32 int with the top 16 bits represents the sequance, and the botten, the alternatre setting no.
+*/
+TInt32 DLddUsbcScChannel::StartNextInAlternateSetting()
+ {
+ iUserKnowsAltSetting = ETrue;
+ return iAsSeq<<16 | iAlternateSetting;
+ }
+
+
+//
+// EpFromAlternateSetting
+//
+
+TInt DLddUsbcScChannel::EpFromAlternateSetting(TUint aAlternateSetting, TInt aEndpoint)
+ {
+ TUsbcScAlternateSetting* alternateSettingListRec = iAlternateSettingList->iHead;
+ 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 KErrNotFound;
+ }
+ }
+ alternateSettingListRec = alternateSettingListRec->iNext;
+ }
+ __KTRACE_OPT(KPANIC, Kern::Printf(" Error: no aAlternateSetting %d found", aAlternateSetting));
+ return KErrNotFound;
+ }
+
+//
+// ProcessAlternateSetting
+//
+
+TInt DLddUsbcScChannel::ProcessAlternateSetting(TUint aAlternateSetting)
+ {
+
+ TUint newSetting = aAlternateSetting&(~KUsbAlternateSetting);
+ __KTRACE_OPT(KUSB, Kern::Printf("ProcessAlternateSetting 0x%08x selecting alternate setting 0x%08x", aAlternateSetting, newSetting));
+ iUserKnowsAltSetting=EFalse;
+ iAlternateSetting = newSetting;
+ iAsSeq++;
+
+ ResetInterface(KErrUsbInterfaceChange); // kill any outstanding IN transfers
+
+ TInt r = SelectAlternateSetting(newSetting);
+ if (r != KErrNone)
+ return r;
+
+
+ StartEpReads();
+ return KErrNone;
+ }
+
+
+//
+// ProcessDeviceState
+//
+// Called from StatusChangeCallback.
+
+TInt DLddUsbcScChannel::ProcessDeviceState(TUsbcDeviceState aDeviceState)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcScChannel::ProcessDeviceState(%d -> %d)", iDeviceState, aDeviceState));
+ if (iDeviceState == aDeviceState)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" No state change => nothing to be done."));
+ return KErrNone;
+ }
+ if (iDeviceState == EUsbcDeviceStateSuspended)
+ {
+ __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 == EUsbcDeviceStateConfigured);
+ TBool deconfigured = EFalse;
+ TInt cancellationCode = KErrNone;
+ if (aDeviceState == EUsbcDeviceStateSuspended)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" Suspending..."));
+ iOldDeviceState = iDeviceState;
+ // Put PSL into low power mode here
+ }
+ else
+ {
+ deconfigured = (iDeviceState == EUsbcDeviceStateConfigured &&
+ aDeviceState != EUsbcDeviceStateConfigured);
+ if (iDeviceState == EUsbcDeviceStateConfigured)
+ {
+ if (aDeviceState == EUsbcDeviceStateUndefined)
+ cancellationCode = KErrUsbCableDetached;
+ else if (aDeviceState == EUsbcDeviceStateAddress)
+ cancellationCode = KErrUsbDeviceNotConfigured;
+ else if (aDeviceState == EUsbcDeviceStateDefault)
+ cancellationCode = KErrUsbDeviceBusReset;
+ else
+ cancellationCode = KErrUsbDeviceNotConfigured;
+ }
+ }
+ 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)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScChannel:: Reumerated!"));
+ // Select main interface & latch in new endpoint set
+ SelectAlternateSetting(0);
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScChannel:: StartReads!"));
+ StartEpReads();
+ }
+ }
+
+ const TInt reqNo = (TInt) RDevUsbcScClient::ERequestReEnumerate;
+ if (renumerateState && iRequestStatus[reqNo])
+ {
+ // This lot must be done if we are reenumerated
+ Kern::RequestComplete(iClient, iRequestStatus[reqNo], KErrNone);
+ }
+
+ return KErrNone;
+ }
+
+
+TBool DLddUsbcScChannel::AlternateDeviceStateTestComplete()
+ {
+ TBool completeNow = EFalse;
+ const TInt reqNo = (TInt) RDevUsbcScClient::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"));
+ // set client descriptor length to zero
+ TInt r = Kern::ThreadRawWrite(iClient, iStatusChangePtr, &deviceState,
+ sizeof(TUint32), iClient);
+ if (r != KErrNone)
+ PanicClientThread(r);
+ iStatusChangePtr = NULL;
+ }
+ }
+ return completeNow;
+ }
+
+
+void DLddUsbcScChannel::DeConfigure(TInt aErrorCode)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcScChannel::DeConfigure()"));
+ // Called after deconfiguration. Cancels transfers on all endpoints.
+ ResetInterface(aErrorCode);
+ // Cancel the endpoint status notify request if it is outstanding.
+ const TInt KEpNotReq = RDevUsbcScClient::ERequestEndpointStatusNotify;
+ if (iRequestStatus[KEpNotReq])
+ {
+ CancelNotifyEndpointStatus();
+ Kern::RequestComplete(iClient, iRequestStatus[KEpNotReq], aErrorCode);
+ }
+ // We have to reset the alternate setting number when the config goes away.
+ SelectAlternateSetting(0);
+ iAlternateSetting = 0;
+ }
+
+
+void DLddUsbcScChannel::StartEpReads()
+ {
+ // Queued after enumeration. Starts reads on all endpoints.
+ // The endpoint itself decides if it can do a read
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcScChannel::StartEpReads - 1"));
+
+ TInt i;
+ TInt8 needsPacket;
+
+ for (i=0; i<iNumBuffers; i++)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcScChannel::StartEpReads - 2 %d",i));
+
+ needsPacket = iBuffers[i].iNeedsPacket;
+ if (needsPacket)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcScChannel::StartEpReads - 3"));
+ iBuffers[i].UpdateBufferList(0,0,(needsPacket==TUsbcScBuffer::KEpIsStarting));
+ }
+ }
+
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcScChannel::StartEpReads - 4"));
+
+ // now update ep0
+ iBuffers[iEP0OutBuff].Ep0CancelLddRead();
+ iBuffers[iEP0OutBuff].UpdateBufferList(0,0);
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcScChannel::StartEpReads - 5"));
+
+ }
+
+
+void DLddUsbcScChannel::ResetInterface(TInt aErrorCode)
+ {
+ if (!iValidInterface && !iOwnsDeviceControl)
+ return;
+
+ TInt i;
+ for (i=0; i<iNumBuffers; i++)
+ {
+ iBuffers[i].iNeedsPacket=TUsbcScBuffer::KNoEpAssigned;
+ }
+
+ TUsbcScBuffer* buffer;
+
+ for (i = 1; i <= iNumberOfEndpoints; i++)
+ {
+ // Firstly, cancel ('garbge collect') any stale reads/writes into PIL.
+
+ __KTRACE_OPT(KUSB, Kern::Printf("Cancelling transfer ep=%d", i));
+ iEndpoint[i]->AbortTransfer();
+
+ // All OUT endpoints need a packet sent, to indicate the termination of the current ep 'pipe'.
+ // This will complete any current read, or will be read later.
+ // All IN endpoints must be simply cancelled, including anything queued.
+ // Ep0 operates outside alt settings, and so we don't cancel anything.
+
+ buffer=iEndpoint[i]->GetBuffer();
+ if (buffer->iDirection==KUsbcScIn)
+ {
+ buffer->iStatusList.Complete(KErrCancel); //aErrorCode
+ buffer->iStatusList.CancelQueued(); //aErrorCode
+ }
+ else
+ buffer->iNeedsPacket=TUsbcScBuffer::KEpIsEnding; // We will send a packet on re-start, which doubles as a 'cancel'
+ // for the old alt setting.
+ }
+ }
+
+
+
+void DLddUsbcScChannel::EmergencyCompleteDfc(TAny* aDLddUsbcScChannel)
+ {
+ ((DLddUsbcScChannel*) aDLddUsbcScChannel)->DoEmergencyComplete();
+ }
+
+TInt DLddUsbcScChannel::DoEmergencyComplete()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcScChannel::DoEmergencyComplete"));
+ // cancel any pending DFCs
+ // complete all client requests
+
+ TUsbcScBuffer* buffer;
+ TInt i;
+ // Complete EP0 request
+
+ TInt direction=iEp0Endpoint->iRequestCallbackInfo->iTransferDir;
+ if (direction==EControllerWrite)
+ {
+ iBuffers[iEP0InBuff].iStatusList.CancelQueued();
+ iBuffers[iEP0InBuff].iStatusList.Complete(KErrDisconnected);
+ }
+ else if (direction==EControllerRead)
+ {
+ iBuffers[iEP0OutBuff].iStatusList.CancelQueued();
+ iBuffers[iEP0OutBuff].iStatusList.Complete(KErrDisconnected);
+ }
+
+ // Complete other Eps request
+ for (i = 1; i <= iNumberOfEndpoints; i++)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Cancelling transfer ep=%d", i));
+ buffer=iEndpoint[i]->GetBuffer();
+ buffer->iStatusList.CancelQueued();
+ buffer->iStatusList.Complete(KErrDisconnected);
+ }
+
+ // Complete remaining requests
+
+ for (TInt i = 0; i < KUsbcMaxRequests; i++)
+ {
+ if (iRequestStatus[i])
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Complete request 0x%x", iRequestStatus[i]));
+ Kern::RequestComplete(iClient, iRequestStatus[i], KErrDisconnected);
+ }
+ }
+ iStatusCallbackInfo.Cancel();
+ iEndpointStatusCallbackInfo.Cancel();
+ iOtgFeatureCallbackInfo.Cancel();
+
+ return KErrNone;
+ }
+
+
+void DLddUsbcScChannel::PanicClientThread(TInt aReason)
+ {
+ Kern::ThreadKill(iClient, EExitPanic, aReason, KUsbLDDKillCat);
+ }
+
+// End DLddUsbcScChannel
+
+/*****************************************************************************\
+* TUsbcScEndpoint *
+* *
+* *
+* *
+\*****************************************************************************/
+
+
+// Constructor
+TUsbcScEndpoint::TUsbcScEndpoint(DLddUsbcScChannel* aLDD, DUsbClientController* aController,
+ const TUsbcScEndpointInfo* aEndpointInfo, TInt aEndpointNum
+ )
+ : iRequestCallbackInfo(NULL),
+ iController(aController),
+ iEndpointInfo(*aEndpointInfo),
+ iClientReadPending(EFalse),
+ iClientWritePending(EFalse),
+ iEndpointNumber(aEndpointNum),
+ iRealEpNumber(-1),
+ iLdd(aLDD),
+ iError(KErrNone),
+ iBytesTransferred(0),
+ iBuffer(NULL)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScEndpoint::TUsbcScEndpoint"));
+ }
+
+
+TInt TUsbcScEndpoint::Construct()
+ {
+ __KTRACE_OPT(KUSB,Kern::Printf("TUsbcScEndpoint::TUsbcScEndpoint iEndpointNumber %d\n",iEndpointNumber));
+
+ iRequestCallbackInfo = new TUsbcRequestCallback(iLdd,
+ iEndpointNumber,
+ (iEndpointNumber==0)?DLddUsbcScChannel::RequestCallbackEp0:TUsbcScEndpoint::RequestCallback,
+ (iEndpointNumber==0)? (TAny*) iLdd: (TAny*) this,
+ iLdd->iDfcQ,
+ KUsbRequestCallbackPriority);
+
+ return (iRequestCallbackInfo == NULL)?KErrNoMemory:KErrNone;
+ }
+
+
+TUsbcScEndpoint::~TUsbcScEndpoint()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScEndpoint::~TUsbcScEndpoint(%d)", iEndpointNumber));
+ AbortTransfer();
+ delete iRequestCallbackInfo;
+ }
+
+// This is called by the PIL, on return from a read or write.
+// Inturn it calls either the read or write function for that buffer.
+
+void TUsbcScEndpoint::RequestCallback(TAny* aTUsbcScEndpoint)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScEndpoint::RequestCallback"));
+
+ if (((TUsbcScEndpoint*)aTUsbcScEndpoint)->iLdd->ChannelClosing())
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("Channel Closing: Completion not accepted!"));
+ return;
+ }
+
+ switch (((TUsbcScEndpoint*) aTUsbcScEndpoint)->iRequestCallbackInfo->iTransferDir)
+ {
+ case EControllerWrite:
+ ((TUsbcScEndpoint*) aTUsbcScEndpoint)->iBuffer->CompleteWrite();
+ return;
+ case EControllerRead:
+ ((TUsbcScEndpoint*) aTUsbcScEndpoint)->iBuffer->CompleteRead();
+ return;
+ default:
+ Kern::Printf("TUsbcScEndpoint::RequestCallback - Unexpected compleation direction %d",((TUsbcScEndpoint*) aTUsbcScEndpoint)->iRequestCallbackInfo->iTransferDir);
+ Kern::Fault("TUsbcScEndpoint::RequestCallback", __LINE__);
+ }
+ }
+
+
+/*
+
+This is used to tidy up cancel calls into the PIL, regardless of them being reads or writes
+
+*/
+
+void TUsbcScEndpoint::AbortTransfer()
+ {
+ if (!iLdd->iRealizeCalled)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScEndpoint::AbortTransfer Ep# %d Real Ep # %d - N.R.",iEndpointNumber, iRealEpNumber));
+ return;
+ }
+ else
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScEndpoint::AbortTransfer Ep# %d Real Ep # %d",iEndpointNumber, iRealEpNumber));
+ }
+
+
+ if (iBuffer && (iBuffer->iStatusList.iState) || (!iRealEpNumber))
+ {
+ if (iRequestCallbackInfo->iTransferDir==EControllerWrite)
+ iController->CancelWriteBuffer(iLdd, iRealEpNumber);
+ else if (iRequestCallbackInfo->iTransferDir==EControllerRead)
+ iController->CancelReadBuffer(iLdd, iRealEpNumber);
+ else
+ {
+ if (iEndpointNumber!=0) // endpoint zero starts off not sent in any direction, then keeps changing.
+ {
+ __KTRACE_OPT(KUSB,Kern::Printf("\nTUsbcScEndpoint::AbortTransfer WARNING: Invalid Direction %d on (%d,%d)!\n",iRequestCallbackInfo->iTransferDir,iEndpointNumber, iRealEpNumber));
+ }
+ else
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("\nTUsbcScEndpoint::AbortTransfer Can't stop direction %d on (%d,%d)!\n",iRequestCallbackInfo->iTransferDir,iEndpointNumber, iRealEpNumber));
+ }
+ }
+ }
+ else if (!iBuffer)
+ {
+ __KTRACE_OPT(KUSB,Kern::Printf("\nTUsbcScEndpoint::AbortTransfer WARNING: iBuffer is NULL on (%d,%d)\n",iEndpointNumber, iRealEpNumber));
+ return;
+ }
+
+ if (iRequestCallbackInfo)
+ iRequestCallbackInfo->iDfc.Cancel();
+ else
+ {
+ __KTRACE_OPT(KUSB,Kern::Printf("\nTUsbcScEndpoint::AbortTransfer WARNING: iRequestCallbackInfo is NULL\n"));
+ }
+
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScEndpoint Done."));
+ }
+
+// End TUsbcScEndpoint
+
+
+/*****************************************************************************\
+* TUsbcScAlternateSettingList *
+* *
+* *
+* *
+\*****************************************************************************/
+
+
+TUsbcScAlternateSetting::TUsbcScAlternateSetting()
+ : iNext(NULL),
+ iPrevious(NULL),
+ iNumberOfEndpoints(0),
+ iSetting(0)
+ {
+ for (TInt i = 0; i <= KMaxEndpointsPerClient; i++)
+ {
+ iEndpoint[i] = NULL;
+ }
+ }
+
+
+TUsbcScAlternateSetting::~TUsbcScAlternateSetting()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScAlternateSetting::~TUsbcScAlternateSetting()"));
+ for (TInt i = 0; i <= KMaxEndpointsPerClient; i++)
+ {
+ delete iEndpoint[i];
+ }
+ }
+
+// End TUsbcScAlternateSettingList
+
+
+
+TUsbcScAlternateSettingList::TUsbcScAlternateSettingList()
+ : iHead(NULL),
+ iTail(NULL)
+ {
+ }
+
+TUsbcScAlternateSettingList::~TUsbcScAlternateSettingList()
+ {
+ }
+
+
+
+/*****************************************************************************\
+* TUsbcDeviceStatusQueue *
+* *
+* *
+* *
+\*****************************************************************************/
+
+
+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;
+ }
+
+// End TUsbcDeviceStatusQueue
+
+//---
+