// Copyright (c) 2000-2010 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"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "d_usbcscTraces.h"

#endif

/*****************************************************************************\

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

		{

		OstTraceDef0(OST_TRACE_CATEGORY_RND, TRACE_FATAL, DUSBCSCLOGDEVICE_INSTALL, "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),

		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 = NULL;

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

{

	OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCCHUNKINFO_CLOSE, "TUsbcScChunkInfo::Close %d", iChunk->AccessCount());

	if (Kern::ChunkClose(iChunk))

        {

		OstTraceDef0(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCCHUNKINFO_CLOSE_DUP1, "TUsbcScChunkInfo::Close1");

        ChunkCleanup();    

		OstTraceDef0(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCCHUNKINFO_CLOSE_DUP2, "TUsbcScChunkInfo::Close2");

        }

}

TInt TUsbcScChunkInfo::ChunkAlloc(TInt aOffset, TInt aSize)

	{

	TUint pageMask = (~0)<<iPageNtz;

	TUint rleMask = ~pageMask;

	TUint pageSize = rleMask+1;

	TInt r;

	TLinAddr physAddr;

	OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCCHUNKINFO_CHUNKALLOC, "::chunkalloc  AllocPhysicalRam aSize %d", aSize);

	r = Epoc::AllocPhysicalRam(aSize, physAddr);

	OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCCHUNKINFO_CHUNKALLOC_DUP1, "::chunkalloc AllocPhysicalRam r=%d  (Error!)", r);

	if (r==KErrNone)

		{	

		OstTraceDefExt5(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCCHUNKINFO_CHUNKALLOC_DUP2, "T::chunkalloc ChunkCommitPhysical iChunk 0x%x size(%d), aOffset 0x%x, aSize 0x%x phsAddr 0x%x", (TUint)iChunk, sizeof(DChunk), aOffset, aSize,(TUint)physAddr);

		r = Kern::ChunkCommitPhysical(iChunk, aOffset, aSize, physAddr);

		if (r!=KErrNone)

		    OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCCHUNKINFO_CHUNKALLOC_DUP3, "::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) 

				{

	            OstTraceDefExt2(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCCHUNKINFO_CHUNKALLOC_DUP4, "::phys offset 0x%x = 0x%x",

                                                (TInt32)((aOffset>>iPageNtz)+i), (TUint32)( (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()

{

	OstTraceDef0(OST_TRACE_CATEGORY_RND, TRACE_FLOW, TUSBCSCCHUNKINFO_CHUNKCLEANUP, "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)

{

    OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCCHUNKINFO_NEW, "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;

		}

	OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCCHUNKINFO_NEW_DUP1, "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;

		OstTraceDefExt2(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCBUFFER_CREATECHUNKBUFFERHEADER, "Realize:  iHead 0x%x  bufferHeader 0x%x", iHead,(TUint)iBufferStart);

		// Dont need to round here, as we will round it up on endpoint change. (configuration)

		}

}

TBool TUsbcScBuffer::IsRequestPending()

	{

		return iStatusList.IsRequestPending();

	}

TBool TUsbcScStatusList::IsRequestPending()

	{

		return (iLength != 0);

	}

/*

TUsbcScBuffer::StartEndpoint

This method sets the nessesary paramenters to the buffer, for use for a particular endpoint.

*/

void TUsbcScBuffer::StartEndpoint(TUsbcRequestCallback* aRequestInfo, TUint aFlags)

	{

	OstTraceDefExt3(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCBUFFER_STARTENDPOINT, "TUsbcScBuffer::StartEndpoint (0x%x) : ep %d(%d)", (TUint)this,aRequestInfo->iEndpointNum, aRequestInfo->iRealEpNum);

	iCallback=aRequestInfo;

	iMaxPacketSize =  iLdd->iController->EndpointPacketSize(iLdd, aRequestInfo->iRealEpNum);

	iAlignMask = ~(((iMaxPacketSize+1) & 0xFFFFFFF8)-1);

	iMode = aFlags;

	OstTraceDefExt3(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCBUFFER_STARTENDPOINT_DUP1, "TUsbcScBuffer::StartEndpoint : max Packets %d, mask 0x%x flags 0x%x", iMaxPacketSize, iAlignMask, (TUint)iMode);

	if ((iDirection&1)==KUsbcScOut)

		{

		OstTraceDef0(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCBUFFER_STARTENDPOINT_DUP2, "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()

{

    OstTraceDef0(OST_TRACE_CATEGORY_RND, TRACE_FLOW, TUSBCSCBUFFER_DESTROY, "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)

	{

        OstTraceDef0(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCBUFFER_STARTDATAREAD, "TUsbcScBuffer::StartDataRead() - Not Configured" );

		return KErrNone;

	}

	if (iStatusList.iState!=ENotRunning) 

		{

	    OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCBUFFER_STARTDATAREAD_DUP1, "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)

		{

		OstTraceDef0(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCBUFFER_STARTDATAREAD_DUP2, "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 # # # #

		{

        OstTraceDefExt3(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCBUFFER_STARTDATAREAD_DUP3, "TUsbcScBuffer::StartDataRead() - tail 0x%x>head 0x%x, maxlength 0x%x", (TUint)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;

			OstTraceDef0(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCBUFFER_STARTDATAREAD_DUP4, "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)

		{

	    OstTraceDefExt2(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCBUFFER_STARTDATAREAD_DUP5, "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)

{

    OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCBUFFER_COMPLETEREAD, "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)

	{

    OstTraceDefExt3(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCBUFFER_UPDATEBUFFERLIST, "TUsbcScBuffer::UpdateBUfferLIst aByteCount %d, flags 0x%x iHead 0x%x", aByteCount, aFlags, (TUint)iHead);

	TInt headerSize =  sizeof(TUsbcScTransferHeader)-4; // TransferHeader includes 4 bytes of data.

	TLinAddr dummy;

	OstTraceDefExt2(OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCSCBUFFER_UPDATEBUFFERLIST_DUP1, "iHead 0x%x headerSize 0x%x",iHead, headerSize);

	// Find iNext

	TInt next =  iHead +  headerSize + aByteCount; // next unused byte in buffer.