// 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),

		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;

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

{

}

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;

			}