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

	}

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();