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

 // All rights reserved.

 // This component and the accompanying materials are made available

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

 // which accompanies this distribution, and is available

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

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // e32\drivers\usbc\usbdma.cpp

 // LDD for USB Device driver stack:

 // Management of DMA-capable data buffers.

 // 

 //

 /**

  @file usbdma.cpp

  @internalTechnology

 */

 #include <drivers/usbc.h>

 #if defined(_DEBUG)

 static const char KUsbPanicLdd[] = "USB LDD";

 #endif

 TDmaBuf::TDmaBuf(TUsbcEndpointInfo* aEndpointInfo, TInt aBandwidthPriority)

 	: iBufBasePtr(NULL),

 	  iCurrentDrainingBuffer(NULL),

 	  iCurrentPacket(0),

 	  iCurrentPacketIndexArray(NULL),

 	  iCurrentPacketSizeArray(NULL)

 	{

 	iMaxPacketSize = aEndpointInfo->iSize;

 	iEndpointType = aEndpointInfo->iType;

 	switch (aEndpointInfo->iType)

 		{

 	case KUsbEpTypeControl:

 		iBufSz = KUsbcDmaBufSzControl;

 		iNumberofBuffers = KUsbcDmaBufNumControl;

 		break;

 	case KUsbEpTypeIsochronous:

 		iBufSz = KUsbcDmaBufSzIsochronous;

 		iNumberofBuffers = KUsbcDmaBufNumIsochronous;

 		break;

 	case KUsbEpTypeBulk:

 		{

 		if (aEndpointInfo->iDir == KUsbEpDirOut)

 			{

 			const TInt priorityOUT = aBandwidthPriority & 0x0f;

 			iBufSz = KUsbcDmaBufSizesBulkOUT[priorityOUT];

 			}

 		else

 			{

 			const TInt priorityIN = (aBandwidthPriority >> 4) & 0x0f;

 			iBufSz = KUsbcDmaBufSizesBulkIN[priorityIN];

 			}

 		iNumberofBuffers = KUsbcDmaBufNumBulk;

 		}

 		break;

 	case KUsbEpTypeInterrupt:

 		iBufSz = KUsbcDmaBufSzInterrupt;

 		iNumberofBuffers = KUsbcDmaBufNumInterrupt;

 		break;

 	default:

 		iBufSz = 0;

 		iNumberofBuffers = 0;

 		}

 	if (aEndpointInfo->iDir == KUsbEpDirIn)

 		{

 		iNumberofBuffers = 1;								// IN endpoints only have 1 buffer

 		}

 	for (TInt i = 0; i < KUsbcDmaBufNumMax; i++)

 		{

 		// Buffer logical addresses (pointers)

 		iBuffers[i] = NULL;

 		// Buffer physical addresses

 		iBufferPhys[i] = 0;

 		// Packet indexes base array

 		iPacketIndex[i] = NULL;

 		// Packet sizes base array

 		iPacketSize[i] = NULL;

 		}

 	}

 TInt TDmaBuf::Construct(TUsbcEndpointInfo* aEndpointInfo)

 	{

 	if (aEndpointInfo->iDir != KUsbEpDirIn)

 		{

 		// IN endpoints don't need a packet array

 		// At most 2 packets (clump of max packet size packets) + possible zlp

 		TUsbcPacketArray* bufPtr = iPacketInfoStorage;

 		// this divides up the packet indexing & packet size array over the number of buffers

 		__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::Construct() array base=0x%08x", bufPtr));

 		for (TInt i = 0; i < iNumberofBuffers; i++)

 			{

 			iPacketIndex[i] = bufPtr;

 			bufPtr += KUsbcDmaBufMaxPkts;

 			iPacketSize[i] = bufPtr;

 			bufPtr += KUsbcDmaBufMaxPkts;

 			__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::Construct() packetIndex[%d]=0x%08x packetSize[%d]=0x%08x",

 											i, iPacketIndex[i], i, iPacketSize[i]));

 			}

 		}

 	else

 		{

 		__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::Construct() IN endpoint"));

 		}

 	Flush();

 	return KErrNone;

 	}

 TDmaBuf::~TDmaBuf()

 	{

 	__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::~TDmaBuf()"));

 	}

 TInt TDmaBuf::BufferTotalSize() const

 	{

 	return iBufSz * iNumberofBuffers;

 	}

 TInt TDmaBuf::BufferSize() const

     {

     return iBufSz;

     }

 TInt TDmaBuf::SetBufferAddr(TInt aBufInd, TUint8* aBufAddr)

     {

     __ASSERT_DEBUG((aBufInd < iNumberofBuffers),

                        Kern::Fault(KUsbPanicLdd, __LINE__));

     iDrainable[aBufInd] = iCanBeFreed[aBufInd] = EFalse;

     iBuffers[aBufInd] = aBufAddr;

     iBufferPhys[aBufInd] = Epoc::LinearToPhysical((TLinAddr)aBufAddr);

     __KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::SetBufferAddr() iBuffers[%d]=0x%08x", aBufInd, iBuffers[aBufInd]));

     return KErrNone;

     }

 TInt TDmaBuf::BufferNumber() const

     {

     return iNumberofBuffers;

     }

 void TDmaBuf::SetMaxPacketSize(TInt aSize)

 	{

 	iMaxPacketSize = aSize;

 	}

 void TDmaBuf::Flush()

 	{

 	__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::Flush %x", this));

 	iRxActive = EFalse;

 	iTxActive = EFalse;

 	iExtractOffset = 0;

 	iTotalRxBytesAvail = 0;

 	iTotalRxPacketsAvail = 0;

 	iCurrentDrainingBufferIndex = KUsbcInvalidBufferIndex;

 	iCurrentFillingBufferIndex = 0;

 	iDrainQueueIndex = KUsbcInvalidDrainQueueIndex;

 	for (TInt i = 0; i < KUsbcDmaBufNumMax; i++)

 		{

 		iDrainable[i] = EFalse;

 		iCanBeFreed[i] = EFalse;

 		iNumberofBytesRx[i] = 0;

 		iNumberofPacketsRx[i] = 0;

 		iError[i] = KErrGeneral;

 		iDrainQueue[i] = KUsbcInvalidBufferIndex;

 #if defined(USBC_LDD_BUFFER_TRACE)

 		iFillingOrderArray[i] = 0;

 		iNumberofBytesRxRemain[i] = 0;

 		iNumberofPacketsRxRemain[i] = 0;

 #endif

 		}

 	// Drain queue is 1 oversized

 	iDrainQueue[KUsbcDmaBufNumMax] = KUsbcInvalidBufferIndex;

 #if defined(USBC_LDD_BUFFER_TRACE)

 	iFillingOrder = 0;

 	iDrainingOrder = 0;

 #endif

 	}

 void TDmaBuf::RxSetActive()

 	{

 	__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxSetActive %x", this));

 	iRxActive = ETrue;

 	}

 void TDmaBuf::RxSetInActive()

 	{

 	__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxSetInActive %x", this));

 	iRxActive = EFalse;

 	}

 TBool TDmaBuf::RxIsActive()

 	{

 	return iRxActive;

 	}

 void TDmaBuf::TxSetActive()

 	{

 	iTxActive = ETrue;

 	}

 void TDmaBuf::TxSetInActive()

 	{

 	iTxActive = EFalse;

 	}

 TBool TDmaBuf::TxIsActive()

 	{

 	return iTxActive;

 	}

 /**************************** Rx DMA Buffer Access *************************/

 void TDmaBuf::ModifyTotalRxBytesAvail(TInt aVal)

 	{

 	iTotalRxBytesAvail += aVal;

 	}

 void TDmaBuf::ModifyTotalRxPacketsAvail(TInt aVal)

 	{

 	iTotalRxPacketsAvail += aVal;

 	}

 TBool TDmaBuf::AdvancePacket()

 	{

 	ModifyTotalRxPacketsAvail(-1);

 	TBool r = ETrue;

 	__ASSERT_DEBUG((iCurrentDrainingBufferIndex >= 0),

 					   Kern::Fault(KUsbPanicLdd, __LINE__));

 	if (++iCurrentPacket >= iNumberofPacketsRx[iCurrentDrainingBufferIndex])

 		{

 		r = NextDrainableBuffer();

 		}

 	iExtractOffset = 0;

 	__ASSERT_DEBUG((iCurrentDrainingBufferIndex == KUsbcInvalidBufferIndex) ||

 				   (iCurrentPacket < KUsbcDmaBufMaxPkts),

 				   Kern::Fault(KUsbPanicLdd, __LINE__));

 	return r;

 	}

 TInt TDmaBuf::PeekNextPacketSize()

 	{

 	TUint pkt = iCurrentPacket;

 	TInt index = iCurrentDrainingBufferIndex;

 	TInt size = -1;

 	if (pkt >= iNumberofPacketsRx[index])

 		{

 		index = PeekNextDrainableBuffer();

 		pkt = 0;

 		}

 	if ((index != KUsbcInvalidBufferIndex) && iNumberofPacketsRx[index])

 		{

 		const TUsbcPacketArray* sizeArray = iPacketSize[index];

 		size = (TInt)sizeArray[pkt];

 		}

 	__ASSERT_DEBUG((iCurrentDrainingBufferIndex == KUsbcInvalidBufferIndex) ||

 				   (iCurrentPacket < KUsbcDmaBufMaxPkts),

 				   Kern::Fault(KUsbPanicLdd, __LINE__));

 	return size;

 	}

 inline TInt TDmaBuf::GetCurrentError()

 	{

 	// USB bus errors are v.rare. To avoid having an error code attached to every packet since

 	// almost every errorcode will be KErrNone, we have a single error code per buffer

 	// If the error code is != KErrNone then it refers to the LAST packet in the buffer

 	TInt errorCode = KErrNone;

 	//Check the index, it's not equal to negative (-1) value defined in 

 	//KUsbcInvalidBufferIndex.

 	__ASSERT_DEBUG((iCurrentDrainingBufferIndex >= 0),

 					   Kern::Fault(KUsbPanicLdd, __LINE__));

 	if (iError[iCurrentDrainingBufferIndex] != KErrNone)

 		{

 		// See if we are at the last packet

 		if ((iCurrentPacket + 1) == iNumberofPacketsRx[iCurrentDrainingBufferIndex])

 			{

 			errorCode = iError[iCurrentDrainingBufferIndex];

 			}

 		}

 	return errorCode;

 	}

 // used to decide whether a client read can complete straight away

 TBool TDmaBuf::IsReaderEmpty()

 	{

 	__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::IsReaderEmpty iTotalRxPacketsAvail=%d",

 									iTotalRxPacketsAvail));

 	return (iTotalRxPacketsAvail == 0);

 	}

 void TDmaBuf::ReadXferComplete(TInt aNoBytesRecv, TInt aNoPacketsRecv, TInt aErrorCode)

 	{

 	// Adjust pending packet

 	if ((aNoBytesRecv == 0) && (aErrorCode != KErrNone))

 		{

 		// Make the buffer available for reuse

 		iDrainable[iCurrentFillingBufferIndex] = EFalse;

 		return;

 		}

 	ModifyTotalRxBytesAvail(aNoBytesRecv);

 	ModifyTotalRxPacketsAvail(aNoPacketsRecv);

 	iNumberofBytesRx[iCurrentFillingBufferIndex] = aNoBytesRecv;

 	iNumberofPacketsRx[iCurrentFillingBufferIndex] = aNoPacketsRecv;

 #if defined(USBC_LDD_BUFFER_TRACE)

 	iNumberofBytesRxRemain[iCurrentFillingBufferIndex] = aNoBytesRecv;

 	iNumberofPacketsRxRemain[iCurrentFillingBufferIndex] = aNoPacketsRecv;

 #endif

 	__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::ReadXferComplete 2 # of bytes=%d # of packets=%d",

 									iTotalRxBytesAvail, iTotalRxPacketsAvail));

 	iDrainable[iCurrentFillingBufferIndex] = ETrue;

 	iError[iCurrentFillingBufferIndex] = aErrorCode;

 	AddToDrainQueue(iCurrentFillingBufferIndex);

 	if (iCurrentDrainingBufferIndex == KUsbcInvalidBufferIndex)

 		{

 		NextDrainableBuffer();

 		}

 	}

 TInt TDmaBuf::RxGetNextXfer(TUint8*& aBufferAddr, TUsbcPacketArray*& aIndexArray,

 							TUsbcPacketArray*& aSizeArray, TInt& aLength, TPhysAddr& aBufferPhys)

 	{

 	__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxGetNextXfer 1"));

 	if (RxIsActive())

 		{

 		__KTRACE_OPT(KUSB, Kern::Printf(" ---> RxIsActive, returning"));

 		return KErrInUse;

 		}

 	__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxGetNextXfer Current buffer=%d",

 									iCurrentFillingBufferIndex));

 	if (iDrainable[iCurrentFillingBufferIndex])

 		{

 		// If the controller refused the last read request, then the current buffer will still be marked

 		// as !Drainable, because the controller never completed the read to the ldd. and therefore the buffer

 		// can be reused.

 		if (!NextFillableBuffer())

 			{

 			return KErrNoMemory;

 			}

 		}

 	__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxGetNextXfer New buffer=%d",

 									iCurrentFillingBufferIndex));

 	aBufferAddr = iBuffers[iCurrentFillingBufferIndex];

 	aBufferPhys = iBufferPhys[iCurrentFillingBufferIndex];

 	aIndexArray = iPacketIndex[iCurrentFillingBufferIndex];

 	aSizeArray = iPacketSize[iCurrentFillingBufferIndex];

 	aLength = iBufSz;

 #if defined(USBC_LDD_BUFFER_TRACE)

 	iFillingOrderArray[iCurrentFillingBufferIndex] = ++iFillingOrder;

 #endif

 	return KErrNone;

 	}

 TInt TDmaBuf::RxCopyPacketToClient(DThread* aThread, TClientBuffer *aTcb, TInt aLength)

 	{

 	__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxCopyPacketToClient 1"));

 #if defined(USBC_LDD_BUFFER_TRACE)

 	const TInt numPkts = NoRxPackets();

 	const TInt numPktsAlt = NoRxPacketsAlt();

 	const TInt numBytes = RxBytesAvailable();

 	const TInt numBytesAlt = NoRxBytesAlt();

 	if (numPkts != numPktsAlt)

 		{

 		Kern::Printf(

 			"TDmaBuf::RxCopyPacketToClient: Error: #pkts mismatch global=%d actual=%d",

 			numPkts, numPktsAlt);

 		}

 	if (numBytes != numBytesAlt)

 		{

 		Kern::Printf(

 			"TDmaBuf::RxCopyPacketToClient: Error: #bytes mismatch global=%d actual=%d",

 			numBytes, numBytesAlt);

 		}

 	if ((numPkts == 0) && (numBytes !=0))

 		{

 		Kern::Printf(

 			"TDmaBuf::RxCopyPacketToClient: Error: global bytes & pkts mismatch pkts=%d bytes=%d",

 			numPkts, numBytes);

 		}

 	if ((numPktsAlt == 0) && (numBytesAlt !=0))

 		{

 		Kern::Printf(

 			"TDmaBuf::RxCopyPacketToClient: Error: actual bytes & pkts mismatch pkts=%d bytes=%d",

 			numPktsAlt, numBytesAlt);

 		}

 #endif

 	if (!NoRxPackets())

 		return KErrNotFound;

 	__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxCopyPacketToClient 2"));

 	// the next condition should be true because we have some packets available

 	// coverity[var_tested_neg]

 	if (iCurrentDrainingBufferIndex == KUsbcInvalidBufferIndex)

 		{

 		// Marked as Coverity "Intentional" as the member variable

 		// iCurrentDrainingBufferIndex is attentionaly negative, from previous 

 		// initialization to KUsbcInvalidBufferIndex (which equals -1).

 		if (!NextDrainableBuffer())

 			return KErrNotFound;

 		}

 	__ASSERT_DEBUG((iCurrentDrainingBufferIndex >= 0 ),

 						   Kern::Fault(KUsbPanicLdd, __LINE__));

 	if (!iDrainable[iCurrentDrainingBufferIndex])

 		return KErrNotFound;

 	// Calculate copy-from address & adjust for the fact that

 	// some data may have already been read from the packet

 	TUint8* logicalSrc = iCurrentDrainingBuffer + iCurrentPacketIndexArray[iCurrentPacket] + iExtractOffset;

 	TInt packetSz = iCurrentPacketSizeArray[iCurrentPacket];

 	TInt thisPacketSz = packetSz - iExtractOffset;

 	TInt errorCode;

 	// try and sort out what a "packet" might mean.

 	// in a multi-packet dma environment, we might see super-packets

 	// i.e. we might just see one packet, maybe 4K or so long, made of lots of small packets

 	// Since we don't know where the packet boundaries will be, we have to assume that

 	// any 'packet' larger than the max packet size of the ep is, in fact, a conglomeration

 	// of smaller packets. However, for the purposes of the packet count, this is still regarded

 	// as a single packet and the packet count only decremented when it is consumed.

 	// As before, if the user fails to read an entire packet out then the next packet is moved onto anyway

 	// To be safe the user must always supply a buffer of at least max packet size bytes.

 	if (thisPacketSz > iMaxPacketSize)

 		{

 		// Multiple packets left in buffer

 		// calculate number of bytes to end of packet

 		if (iEndpointType == KUsbEpTypeBulk)

 			{

 			thisPacketSz = iMaxPacketSize - (iExtractOffset & (iMaxPacketSize - 1));

 			}

 		else

 			{

 			thisPacketSz = iMaxPacketSize - (iExtractOffset % iMaxPacketSize);

 			}

 		errorCode = KErrNone;

 		}

 	else

 		{

 		errorCode = GetCurrentError();						// single packet left

 		}

 	iExtractOffset += thisPacketSz;			// iExtractOffset is now at the end of the real or notional packet

 	ModifyTotalRxBytesAvail(-thisPacketSz);

 #if defined(USBC_LDD_BUFFER_TRACE)

 	iNumberofBytesRxRemain[iCurrentDrainingBufferIndex] -= thisPacketSz;

 #endif

 	// this can only be untrue if the "packet" is a conglomeration of smaller packets:

 	if (iExtractOffset == packetSz)

 		{

 		// packet consumed, advance to next packet in buffer

 #if defined(USBC_LDD_BUFFER_TRACE)

 		iNumberofPacketsRxRemain[iCurrentDrainingBufferIndex] -= 1;

 #endif

 		AdvancePacket();

 		}

 	TPtrC8 des(logicalSrc, thisPacketSz);

 	TInt r=Kern::ThreadBufWrite(aThread, aTcb, des, 0, 0, aThread);

 	if (r == KErrNone)

 		{

 		r = errorCode;

 		}

 	__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxCopyPacketToClient 3"));

 	FreeDrainedBuffers();

 	// Use this error code to complete client read request:

 	return r;

 	}

 TInt TDmaBuf::RxCopyDataToClient(DThread* aThread, TClientBuffer *aTcb, TInt aLength, TUint32& aDestOffset,

 								 TBool aRUS, TBool& aCompleteNow)

 	{

 	__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxCopyDataToClient 1"));

 	aCompleteNow = ETrue;

 #if defined(USBC_LDD_BUFFER_TRACE)

 	const TInt numPkts = NoRxPackets();

 	const TInt numPktsAlt = NoRxPacketsAlt();

 	const TInt numBytes = RxBytesAvailable();

 	const TInt numBytesAlt = NoRxBytesAlt();

 	if (numPkts != numPktsAlt)

 		{

 		Kern::Printf(

 			"TDmaBuf::RxCopyDataToClient: Error: #pkts mismatch global=%d actual=%d",

 			numPkts, numPktsAlt);

 		}

 	if (numBytes != numBytesAlt)

 		{

 		Kern::Printf(

 			"TDmaBuf::RxCopyDataToClient: Error: #bytes mismatch global=%d actual=%d",

 			numBytes, numBytesAlt);

 		}

 	if ((numPkts == 0) && (numBytes != 0))

 		{

 		Kern::Printf(

 			"TDmaBuf::RxCopyDataToClient: Error: global bytes & pkts mismatch pkts=%d bytes=%d",

 			numPkts, numBytes);

 		}

 	if ((numPktsAlt == 0) && (numBytesAlt != 0))

 		{

 		Kern::Printf(

 			"TDmaBuf::RxCopyDataToClient: Error: actual bytes & pkts mismatch pkts=%d bytes=%d",

 			numPktsAlt, numBytesAlt);

 		}

 #endif

 	if (!NoRxPackets())

 		{

 		return KErrNotFound;

 		}

 	// coverity[var_tested_neg]

 	if (iCurrentDrainingBufferIndex == KUsbcInvalidBufferIndex)

 		{

 		// Marked as Coverity "Inentional" as the member variable

 		// iCurrentDrainingBufferIndex is attentionaly negative, from previous 

 		// initialization to KUsbcInvalidBufferIndex (which equals -1).

 		if (!NextDrainableBuffer())

 			{

 #if defined(USBC_LDD_BUFFER_TRACE)

 			Kern::Printf("TDmaBuf::RxCopyDataToClient: Error:  No buffer draining=%d, packets=%d",

 						 iCurrentDrainingBufferIndex, iTotalRxPacketsAvail);

 #endif

 			return KErrNotFound;

 			}

 		}

 #if defined(USBC_LDD_BUFFER_TRACE)

 	__ASSERT_DEBUG((iCurrentDrainingBufferIndex >= 0 ),

 							   Kern::Fault(KUsbPanicLdd, __LINE__));

 	if (iDrainingOrder != iFillingOrderArray[iCurrentDrainingBufferIndex])

 		{

 		Kern::Printf("!!! Out of Order Draining TDmaBuf::RxCopyDataToClient 10 draining=%d",

 					 iCurrentDrainingBufferIndex);

 		}

 #endif

 	__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxCopyDataToClient 2"));

 	TUint8* blockStartAddr = iCurrentDrainingBuffer + iCurrentPacketIndexArray[iCurrentPacket] + iExtractOffset;

 	TUint8* lastEndAddr = blockStartAddr;					// going to track the contiguity of the memory

 	TUint8* thisStartAddr = blockStartAddr;

 	TInt toDo = Min(aLength - (TInt)aDestOffset, iTotalRxBytesAvail);

 #if defined(USBC_LDD_BUFFER_TRACE)

 	TInt bufnum = iCurrentDrainingBufferIndex;

 #endif

 	TInt errorCode = KErrNone;

 	TBool isShortPacket = EFalse;

 	const TInt maxPacketSizeMask = iMaxPacketSize - 1;

 	do

 		{

 #if defined(USBC_LDD_BUFFER_TRACE)

 		if (bufnum != iCurrentDrainingBufferIndex)

 			{

 			bufnum = iCurrentDrainingBufferIndex;

 			if (iDrainingOrder != iFillingOrderArray[iCurrentDrainingBufferIndex])

 				{

 				Kern::Printf("!!! Out of Order Draining TDmaBuf::RxCopyDataToClient 20 draining=%d",

 							 iCurrentDrainingBufferIndex);

 				}

 			}

 #endif

 		if (errorCode == KErrNone)

 			{

 			errorCode = GetCurrentError();

 			}

 		thisStartAddr = iCurrentDrainingBuffer + iCurrentPacketIndexArray[iCurrentPacket] + iExtractOffset;

 		const TInt thisPacketSize = iCurrentPacketSizeArray[iCurrentPacket];

 		const TInt size = thisPacketSize - iExtractOffset;

 		if (aRUS)

 			{

 			if (iEndpointType == KUsbEpTypeBulk)

 				{

 				isShortPacket = (size < iMaxPacketSize) || (size & maxPacketSizeMask);

 				}

 			else

 				{

 				// this 'if' block is arranged to avoid a division on packet sizes <= iMaxPacketSize

 				isShortPacket = (size < iMaxPacketSize) ||

 					((size > iMaxPacketSize) && (size % iMaxPacketSize));

 				}

 			}

 		TInt copySize = Min(size, toDo);

 		iExtractOffset += copySize;

 		toDo -= copySize;

 		if (thisStartAddr != lastEndAddr)

 			{

 			TInt bytesToCopy = lastEndAddr - blockStartAddr;

 			TInt r=CopyToUser(aThread, blockStartAddr, bytesToCopy, aTcb, aDestOffset);

 			if(r != KErrNone)

 				Kern::ThreadKill(aThread, EExitPanic, r, KUsbLDDKillCat);

 			blockStartAddr = thisStartAddr;

 			}

 		ModifyTotalRxBytesAvail(-copySize);

 #if defined(USBC_LDD_BUFFER_TRACE)

 		iNumberofBytesRxRemain[iCurrentDrainingBufferIndex] -= copySize;

 #endif

 		lastEndAddr = thisStartAddr + copySize;

 		if (iExtractOffset == thisPacketSize)

 			{

 			// More data to copy, so need to access new packet

 #if defined(USBC_LDD_BUFFER_TRACE)

 			iNumberofPacketsRxRemain[iCurrentDrainingBufferIndex] -= 1;

 #endif

 			if (!AdvancePacket())

 				{

 				break;										// no more packets left

 				}

 			}

 		} while (toDo > 0 && !isShortPacket);

 	if (thisStartAddr != lastEndAddr)

 		{

 		TInt bytesToCopy = lastEndAddr - blockStartAddr;

 		TInt r=CopyToUser(aThread, blockStartAddr, bytesToCopy, aTcb, aDestOffset);

 		if(r != KErrNone)

 			Kern::ThreadKill(aThread, EExitPanic, r, KUsbLDDKillCat);

 		}

 	// If we have transferred the requested amount of data it is still possible that

 	// the next packet is a zlp which needs to be bumped over

 	if (aRUS && (toDo == 0) && (iExtractOffset == 0) && (!isShortPacket) && (!IsReaderEmpty()) &&

 		(PeekNextPacketSize() == 0))

 		{

 		// swallow a zlp

 		isShortPacket = ETrue;

 #if defined(USBC_LDD_BUFFER_TRACE)

 		iNumberofPacketsRxRemain[iCurrentDrainingBufferIndex] -= 1;

 #endif

 		AdvancePacket();

 		}

 	aCompleteNow = isShortPacket || (((TInt)aDestOffset) == aLength) || (errorCode != KErrNone);

 	FreeDrainedBuffers();

 	// Use this error code to complete client read request

 	return errorCode;

 	}

 inline TInt TDmaBuf::CopyToUser(DThread* aThread, const TUint8* aSourceAddr,

 								TInt aLength, TClientBuffer *aTcb, TUint32& aDestOffset)

 	{

 	TPtrC8 des(aSourceAddr, aLength);

 	TInt errorCode = Kern::ThreadBufWrite(aThread, aTcb, des, aDestOffset, KChunkShiftBy0, aThread);

 	if (errorCode == KErrNone)

 		{

 		aDestOffset += aLength;

 		}

 	return errorCode;

 	}

 inline TInt TDmaBuf::NoRxPackets() const

 	{

 	return iTotalRxPacketsAvail;

 	}

 inline void TDmaBuf::IncrementBufferIndex(TInt& aIndex)

 	{

 	if (++aIndex == iNumberofBuffers)

 		aIndex = 0;

 	}

 TBool TDmaBuf::NextDrainableBuffer()

 	{

 	TBool r = EFalse;

 	if (iCurrentDrainingBufferIndex != KUsbcInvalidBufferIndex)

 		{

 		iCanBeFreed[iCurrentDrainingBufferIndex] = ETrue;

 		iNumberofPacketsRx[iCurrentDrainingBufferIndex] = 0; // Current buffer is empty

 		iNumberofBytesRx[iCurrentDrainingBufferIndex] = 0;	// Current buffer is empty

 #if defined(USBC_LDD_BUFFER_TRACE)

 		TUint& bytesRemain = iNumberofBytesRxRemain[iCurrentDrainingBufferIndex];

 		TUint& pktsRemain = iNumberofPacketsRxRemain[iCurrentDrainingBufferIndex];

 		if ((bytesRemain != 0) || (pktsRemain != 0))

 			{

 			Kern::Printf(

 				"TDmaBuf::NextDrainableBuffer: Error: data discarded buffer=%d pkts=%d bytes=%d",

 				iCurrentDrainingBufferIndex, pktsRemain, bytesRemain);

 			bytesRemain = 0;

 			pktsRemain = 0;

 			}

 #endif

 		iCurrentDrainingBufferIndex = KUsbcInvalidBufferIndex;

 		iCurrentPacket = KUsbcInvalidPacketIndex;

 		}

 	if (iDrainQueueIndex != KUsbcInvalidDrainQueueIndex)

 		{

 		r = ETrue;

 		const TInt index = iDrainQueue[0];

 		iDrainQueueIndex--;

 		for (TInt i = 0; i < iNumberofBuffers; i++)

 			{

 			iDrainQueue[i] = iDrainQueue[i+1];

 			}

 #if defined(USBC_LDD_BUFFER_TRACE)

 		if (index != KUsbcInvalidBufferIndex)

 			iDrainingOrder++;

 #endif

 		iCurrentDrainingBufferIndex = index;

 		iCurrentDrainingBuffer = iBuffers[index];

 		iCurrentPacketIndexArray = iPacketIndex[index];

 		iCurrentPacketSizeArray = iPacketSize[index];

 		iCurrentPacket = 0;

 		}

 	return r;

 	}

 TInt TDmaBuf::PeekNextDrainableBuffer()

 	{

 	TInt r = KUsbcInvalidBufferIndex;

 	if (iDrainQueueIndex != KUsbcInvalidDrainQueueIndex)

 		{

 		r = iDrainQueue[0];

 		}

 	return r;

 	}

 TBool TDmaBuf::NextFillableBuffer()

 	{

 	TBool r = EFalse;

 	TInt index = iCurrentFillingBufferIndex;

 	IncrementBufferIndex(index);

 	// the sequence will restart at 0 if a buffer can't be found this time

 	iCurrentFillingBufferIndex = 0;

 	for (TInt i = 0; i < iNumberofBuffers; i++)

 		{

 		if (!iDrainable[index])

 			{

 			iCurrentFillingBufferIndex = index;

 			r = ETrue;

 			break;

 			}

 		IncrementBufferIndex(index);

 		}

 	return r;

 	}

 void TDmaBuf::FreeDrainedBuffers()

 	{

 	for (TInt i = 0; i < iNumberofBuffers; i++)

 		{

 		if (iDrainable[i] && iCanBeFreed[i])

 			{

 			iDrainable[i] = iCanBeFreed[i] = EFalse;

 			}

 		}

 	}

 TBool TDmaBuf::ShortPacketExists()

 	{

 	// Actually, a short packet or residue data

 	__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::ShortPacketExists 1"));

 	TInt index = iCurrentDrainingBufferIndex;

 	TUsbcPacketArray* pktSizeArray = iCurrentPacketSizeArray;

 	if (iMaxPacketSize > 0)

 		{

 		// No buffers available for draining

 		if ((iCurrentDrainingBufferIndex == KUsbcInvalidBufferIndex) ||

 			(iCurrentPacket == KUsbcInvalidPacketIndex))

 			return EFalse;

 		// Zlp waiting at tail

 		if ((iTotalRxBytesAvail == 0) && (NoRxPackets() == 1))

 			return ETrue;

 		if (iEndpointType == KUsbEpTypeBulk)

 			{

 			const TInt mask = iMaxPacketSize - 1;

 			if (iTotalRxBytesAvail & mask)

 				return ETrue;

 			// residue==0; this can be because

 			// zlps exist, or short packets combine to n * max_packet_size

 			// This means spadework

 			const TInt s = iCurrentPacketSizeArray[iCurrentPacket] - iExtractOffset;

 			if ((s == 0) || (s & mask))

 				{

 				return ETrue;

 				}

 			for (TInt i = 0; i < iNumberofBuffers; i++)

 				{

 				if (index == KUsbcInvalidBufferIndex)

 					break;

 				if (iDrainable[index])

 					{

 					const TInt packetCount = iNumberofPacketsRx[index];

 					const TInt lastPacketSize=pktSizeArray[packetCount - 1];

 					if ((lastPacketSize < iMaxPacketSize) || (lastPacketSize & mask))

 						{

 						return ETrue;

 						}

 					}

 				index = iDrainQueue[i];

 				pktSizeArray = iPacketSize[index];

 				}

 			}

 		else

 			{

 			if (iTotalRxBytesAvail % iMaxPacketSize)

 				return ETrue;

 			// residue==0; this can be because

 			// zlps exist, or short packets combine to n * max_packet_size

 			// This means spadework

 			const TInt s = iCurrentPacketSizeArray[iCurrentPacket] - iExtractOffset;

 			if ((s == 0) || (s % iMaxPacketSize))

 				{

 				return ETrue;

 				}

 			for (TInt i = 0; i < iNumberofBuffers; i++)

 				{

 				if (index == KUsbcInvalidBufferIndex)

 					break;

 				if (iDrainable[index])

 					{

 					const TInt packetCount = iNumberofPacketsRx[index];

 					const TInt lastPacketSize = pktSizeArray[packetCount - 1];

 					if ((lastPacketSize < iMaxPacketSize) || (lastPacketSize % iMaxPacketSize))

 						{

 						return ETrue;

 						}

 					}

 				index = iDrainQueue[i];

 				pktSizeArray = iPacketSize[index];

 				}

 			}

 		}

 	return EFalse;

 	}

 void TDmaBuf::AddToDrainQueue(TInt aBufferIndex)

 	{

 	if (iDrainQueue[iDrainQueueIndex + 1] != KUsbcInvalidBufferIndex)

 		{

 #if defined(USBC_LDD_BUFFER_TRACE)

 		Kern::Printf("TDmaBuf::AddToDrainQueue: Error: invalid iDrainQueue[x]");

 #endif

 		}

 	iDrainQueue[++iDrainQueueIndex] = aBufferIndex;

 	}

 #if defined(USBC_LDD_BUFFER_TRACE)

 TInt TDmaBuf::NoRxPacketsAlt() const

 	{

 	TInt pktCount = 0;

 	for(TInt i = 0; i < iNumberofBuffers; i++)

 		{

 		if (iDrainable[i])

 			{

 			pktCount += iNumberofPacketsRxRemain[i];

 			}

 		}

 	return pktCount;

 	}

 TInt TDmaBuf::NoRxBytesAlt() const

 	{

 	TInt byteCount = 0;

 	for(TInt i = 0; i < iNumberofBuffers; i++)

 		{

 		if (iDrainable[i])

 			{

 			byteCount += iNumberofBytesRxRemain[i];

 			}

 		}

 	return byteCount;

 	}

 #endif

 // We only store 1 transaction, no other buffering is done

 TInt TDmaBuf::TxStoreData(DThread* aThread, TClientBuffer *aTcb, TInt aTxLength, TUint32 aBufferOffset)

 	{

 	__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::TxStoreData 1"));

 	if (!IsReaderEmpty())

 		return KErrInUse;

 	__KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::TxStoreData 2"));

 	TInt remainTxLength = aTxLength;

 	TUint32 bufferOffset = aBufferOffset;

 	// Store each buffer separately

 	for( TInt i=0;(i<iNumberofBuffers)&&(remainTxLength>0);i++)

 	    {

 	    TUint8* logicalDest = iBuffers[i];

 	    TInt xferSz = Min(remainTxLength, iBufSz);

 	    TPtr8 des(logicalDest, xferSz, xferSz);

 	    TInt r = Kern::ThreadBufRead(aThread, aTcb, des, bufferOffset, KChunkShiftBy0);

 	    if(r != KErrNone)

 	        {

 	        Kern::ThreadKill(aThread, EExitPanic, r, KUsbLDDKillCat);

 	        return r;

 	        }

 	    remainTxLength -= iBufSz;

 	    bufferOffset += iBufSz;

 	    }

 	return KErrNone;

 	}

 TInt TDmaBuf::TxGetNextXfer(TUint8*& aBufferAddr, TInt& aTxLength, TPhysAddr& aBufferPhys)

 	{

 	if (iTxActive)

 		return KErrInUse;

 	aBufferAddr = iBuffers[0];								// only 1 tx buffer

 	aBufferPhys = iBufferPhys[0];

 	aTxLength = BufferTotalSize();

 	return KErrNone;

 	}