// 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;

	}