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

		iCleanup((TDfcFn)&DfcChunkCleanup,this,Kern::SvMsgQue(),0),

		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 = &iCleanup;

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

{

	Kern::ChunkClose(iChunk);	

}

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;

			}

		// Not enough space, move onto next block.

		if (maxLength<iMinReadSize) 

			{

			next+=maxLength;

			__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UpdateBUfferLIst Skip exhausted block. next %x max %d", next, maxLength));

			continue;

			}

		}

	while (EFalse);

	__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UpdateBUfferLIst next (pre deduct): %x, Fill in header at head: 0x%x,  BuffStart: 0x%x.", next, iHead, iBufferStart));

	next -=  headerSize;  // Move next back from the data start position, to the header start.

	TUsbcScTransferHeader* header = (TUsbcScTransferHeader*) (iHead + iChunkAddr);

// Create Header

#ifdef _DEBUG

	header->iHashId=59*(iLdd->iAlternateSetting+1)+iCallback->iRealEpNum; // Alt setting realated....

	header->iSequence=iSequence;

	iSequence++;

#endif

	header->iBytes=aByteCount;

	header->iNext=next;

	header->iAltSettingSeq=iLdd->iAsSeq;

	header->iAltSetting=iLdd->iAlternateSetting;

	header->iFlags=aFlags;

	__KTRACE_OPT(KUSB, Kern::Printf("We set next to 0x%x", next));

	iStatusList.iState=ENotRunning;

	if (next==iBufferStart->iTail) //or (othwise is as good as full)

		{

			iStalled=next;

		}

	else

		{

		__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UpdateBUfferLIst StartRead?? "));

		TInt oldHead=iHead;

		iHead = next;

		if ((aStartNextRead) && (StartDataRead() == KErrOverflow))

			{ // Oh crumbs, set state as slalled.

			if (oldHead != iBufferStart->iBilTail) 

				// If user has not read everything in the buffer

				// then set up a stall, so that ldd get to be woken early

				{

				iStalled=next;

				iHead=oldHead;

				}

			else // otherwise if everything is read

				// no choice but to return what we have

				{

				iBufferStart->iHead = iHead;

				}

			}

		else

			{

			iBufferStart->iHead = next;

			__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UpdateBUfferLIst Compleating\n"));

			}

		// Complete userside

		iStatusList.Complete();

		}  

	}

void TUsbcScBuffer::PopStall()

	{

	if (iStalled==iBufferStart->iTail)

		return;  // Still stalled.

	if (iStalled!=-1) // If not Alt packet only stall

	{

		// pop off packet	

		iHead = iStalled;

 	}

	iStalled=0;

	// If Alt setting of the popped packet is different to now

	// Add alt setting change packet.

	if (StartDataRead() == KErrOverflow)

	{

		__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::PopStall Warning: Transfer was freed, but still no space!\n"));

	}

	iBufferStart->iHead = iHead;

	}

void TUsbcScBuffer::StartDataWrite()

	{

	__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartDataWrite()"));

	TUsbcScStatusElement* nextJob = iStatusList.Next();

	TBool zlpReqd;

	TInt length;

	TUint start;

	TUint8* startAddr;

	TInt maxLength;

	TPhysAddr physAddr;

	TInt r;

	if (!iMaxPacketSize)

	{

		__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartDataWrite() - Not Configured"));

		return;

	}

	if (nextJob == NULL)

		{

		__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartDataWrite() - No more jobs d=%d", iDirection));

		if (iDirection==KUsbcScBiIn) // assume this is EP0, if this is true.

			{

			__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartDataWrite() Queue Read on EP0."));	

			// Start other read again.

			iLdd->iBuffers[iLdd->iEP0OutBuff].StartDataRead();

			}

		}

	else

		{

		if (iStatusList.iState==ENotRunning)

			iSent=0;

		iStatusList.iState=EInProgress;

		start = nextJob->iStart;

		startAddr = (TUint8*) (start + ((TUint) (iChunkInfo->iChunkMem)));

		length = nextJob->iLength;

		zlpReqd = (nextJob->iFlags & KUsbcScWriteFlagsZlp) !=0;

		// get max read length

		maxLength = iChunkInfo->GetPhysical( start, &physAddr); 

		if (maxLength < length)

			{

				// modify request.

				nextJob->iStart += maxLength;

				nextJob->iLength -= maxLength;

				// start this request.

				iStatusList.iState=EFramgementInProgress;

				zlpReqd=EFalse;

				length =  maxLength;

			}

		if (iDirection==KUsbcScBiIn) // this is for EP0

			{

			iLdd->iController->CancelReadBuffer(iLdd, iCallback->iRealEpNum);

			iLdd->iBuffers[iLdd->iEP0OutBuff].iStatusList.iState=ENotRunning;

			}

		iCallback->SetTxBufferInfo(startAddr, physAddr, length);

		iCallback->iZlpReqd = zlpReqd;

		r = iLdd->iController->SetupWriteBuffer(*iCallback);

		if (r!=KErrNone)

			{

			__KTRACE_OPT(KUSB, Kern::Printf("SetupWriteBUffer Error: %d",r));

			iStatusList.Complete(r);

			}

		}

	}

void TUsbcScBuffer::CompleteWrite()

	{

	TInt error = iCallback->iError;

	__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::CompleteWrite buff=%x, err=%d",this, error));

	iSent+= iCallback->iTxBytes;

	// More to send?

	if (error || iStatusList.iState!=EFramgementInProgress)

		{

		// complete request with error (if one).

		// Some data could have been transmitted, even with an error. 

		iStatusList.Complete(error);

		}

	// Start next request, or next part of this one.

	StartDataWrite();

	}

// Cancels the current request's callback.

// This is not to say it will cancel the actual operation,

// However it will cancel any further sections of the user perceived operation

// that are not yet started.

void TUsbcScBuffer::Cancel(TInt aErrorCode)

	{

	iStatusList.CancelQueued();

	if (iLdd->iController && ((iDirection&1)==KUsbcScIn))

		{

		iLdd->iController->CancelWriteBuffer(iLdd, iCallback->iRealEpNum);

		}

	iStatusList.Complete(aErrorCode);

	}

void TUsbcScBuffer::Ep0CancelLddRead()

	{

	// Stopping a read isn't as easy as one might think.

	// We cancel the callback, but then check if any data was received (but not returned to us).

	// If so, we must de-queue the request, and call the completion code.

	iLdd->iController->CancelReadBuffer(iLdd, iCallback->iRealEpNum);

	if (iCallback->iRxPackets) // received data?

		{

		// remove DFC (if infact sent)

		iCallback->iDfc.Cancel();

		// process the callback now, but dont start another

		CompleteRead(EFalse);

		}

	}

void TUsbcScBuffer::SendEp0StatusPacket(TInt aState)

{

	__KTRACE_OPT(KUSB, Kern::Printf(" TUsbcScBuffer::SendEp0StatusPacket(%d)", aState));

	// We need to add a packet to the buffer, so we must stop the pending read, and start

	// another after we have added out packet.  

	Ep0CancelLddRead();

	TUint* state = ((TUsbcScTransferHeader *) (iHead + iChunkAddr))->iData.i;

	*state = aState;

	UpdateBufferList(4,KUsbcScStateChange);

}

// End TUsbcScBuffer

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

*    TUsbcScStatusList                                                        *

*                                                                             *

*    This is a list of read or write requests, containing user status         *

*    requests, that should later be completed.                                *

*                                                                             *

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

/**

Constructor for TUsbcScStatusList.

@param aSize	is the number of requests to allow at any one time.  This value

				must be a power of two, for correct operation.

@returns KErrNoMemory if memory allocation failure, otherwise KErrNone.

*/

TInt TUsbcScStatusList::Construct(TInt aSize, DThread* aClient)

	{

	iSize=aSize;

	iHead = 0;

	iLength = 0;

	iClient = aClient;

	iElements=(TUsbcScStatusElement *) Kern::AllocZ(sizeof(TUsbcScStatusElement)*aSize);

	return (iElements==NULL)?KErrNoMemory:KErrNone;	

	};

// StatusList must be inactive before destroying.

void TUsbcScStatusList::Destroy()

	{

	if (iState!=ENotRunning)

		Kern::Fault("TUsbcScStatusList::Destroy", __LINE__);

	if (iElements)

		{

		Kern::Free(iElements);	

		iElements=NULL;

		}

	iClient=NULL;

}

void TUsbcScStatusList::Pop()

	{

	if (iLength>0)

		{

		iLength--;

		iHead = ((iHead+1) & (iSize-1));

		}

	}

TUsbcScStatusElement* TUsbcScStatusList::Next()

	{

	return (iLength==0)?NULL:&(iElements[iHead]);

	}

TInt TUsbcScStatusList ::Add(TRequestStatus* aStatus, TInt aLength, TUint aStart, TUint aFlags)

	{

	__KTRACE_OPT(KUSB,Kern::Printf("Adding request.  iLength %d  iSize %d", iLength, iSize));

	if (iLength<iSize)

		{

		TUsbcScStatusElement& e = iElements[((iHead+iLength) & (iSize-1))];

		e.iStatus = aStatus;

		e.iLength = aLength;

		e.iStart = aStart;

		e.iFlags = aFlags;

		iLength++;

		__KTRACE_OPT(KUSB,Kern::Printf("Adding request.  new iLength %d", iLength));

		return KErrNone;

		}

	else

		return KErrInUse;

	}

// This method cancels any requests that have yet to be started.

void TUsbcScStatusList::CancelQueued(TInt aError)

{

	if ((iLength==0) || ((iState!=ENotRunning) && (iLength==1)))  // Nothing to do.

		return;  

	TInt elements2Complete = iLength - (iState?1:0);

	TInt head = iHead;

	iLength = 0;

	if (iState)	// If (iState != ENotRunning), complete all elements excepting the one at head

		{

		head = ((head+1) & (iSize-1)); // To iterate through the queue

		iLength = 1;

		}

	// complete them all.

	for (; elements2Complete>0; elements2Complete--)

  		{

		Kern::RequestComplete(iClient, iElements[head].iStatus, aError);

		head = ((head+1) & (iSize-1)); 

  		}

}

/* This method Completes the head status request, and pops it from its list.

This version of Complete is to be used in cases where the next request is not

chained - usually because of an error.

@Param aError - the code to complete with.

returns KErrNotFound if there was no request to complete

*/

TInt TUsbcScStatusList::Complete(TInt aError)

	{

	if (iState==ENotRunning)

		{

		__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScStatusList::Complete() - iState == ENotRunning!"));

		}

 	else

		{

		iState=ENotRunning;

		if (iLength==0)

			return KErrNotFound;

		Kern::RequestComplete(iClient, iElements[iHead].iStatus, aError);

		iLength--;

		iHead = ((iHead+1) & (iSize-1));

		}

	return KErrNone;

	}

/* This method Completes the head status request, and pops it from its list. (If found.)

This version of Complete is to be used in cases where the request is successful, and

 next request after this has (if present) been chained.

*/

void TUsbcScStatusList::Complete()

	{

	if (iLength==0)

		return;

	__KTRACE_OPT(KUSB, Kern::Printf("Completing request.  iLength %d", iLength));

	Kern::RequestComplete(iClient, iElements[iHead].iStatus, KErrNone);

	iLength--;

	iHead = ((iHead+1) & (iSize-1));

	}

// End TUsbcScStatusList

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

*   TRealizeInfo                                                              *

*                                                                             *

*   Used by DLddUsbcScChannel::RealizeInterface to set up the chunk           *

*                                                                             *

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

// Init

//

// This method works out the number potential maximum number of endpoints

// and the number of alt settings.  With this information it allocs

// the necessary space for the given stucture to store information about

// the endpoints.  

// This is intended to be called by RealizeInterface.  This stucture is

// intended to be only temporary, and the space will be freed with Free()

// before RealizeInteface has finished.

void TRealizeInfo::Init(TUsbcScAlternateSettingList* aAlternateSettingList)

{

	iAlternateSettingList = aAlternateSettingList;

	iMaxEndpoints=0;

	iTotalSize   =0;

	iTotalBuffers=0;

	iAltSettings =0;

	__KTRACE_OPT(KUSB, Kern::Printf("Realize: work out max endpoint"));

	// Work out max endpoints and number of alternate settings.

	if (iAlternateSettingList)

		{

		TUsbcScAlternateSetting* alt = iAlternateSettingList->iHead;

		while (alt != NULL) 

			{

			iAltSettings++;

			if (alt->iNumberOfEndpoints>iMaxEndpoints)

				iMaxEndpoints = alt->iNumberOfEndpoints;

			// could work out in/out specifics, but unnecessary.

			alt = alt->iNext;

			};

		}

	// Alloc some temporary working space for temp endpoint metadata 

	__KTRACE_OPT(KUSB, Kern::Printf("Realize: Alloc temp.  Maxendpoints %d", iMaxEndpoints));

	TInt inout;

	for (inout=KUsbcScIn; inout<KUsbcScDirections; inout++)

		{

		iBufs[inout].iEp = (TUsbcScEndpoint **) Kern::AllocZ(iAltSettings*iMaxEndpoints*sizeof(TUsbcScEndpoint *));

		iBufs[inout].iSizes = (TInt *) Kern::AllocZ(iMaxEndpoints*sizeof(TInt));

		}

}

// CopyAndSortEndpoints

//

// This method copies pointers to the endpoint records into TRealizeInfo

// such that they are sorted in order of size per alt setting.

// In and Out endpoints are separated, and kept separate.

// The provided data structure is assumed to have been initialised with

// Realize_InitRealizeInfo. 

//

// Return KErrArgument if the direction field is neither In or Out.

//

TInt TRealizeInfo::CopyAndSortEndpoints()

	{

	__KTRACE_OPT(KUSB, Kern::Printf("Realize: copy And sort"));

	TInt altSetting = 0;

	TInt endpointOffs;

	TInt endpoint;

	TInt altEp;

	TInt inout;

	TBool placed;

	TUsbcScAlternateSetting* alt;

	TEndpointSortBufs* bufsd;

	if (iAlternateSettingList)

		{

		for (alt = iAlternateSettingList->iHead;alt!=NULL;alt = alt->iNext )

			{		

			__KTRACE_OPT(KUSB, Kern::Printf("Realize:   AlternateSetting %x", alt));

			iBufs[KUsbcScIn].iEps =0;

			iBufs[KUsbcScOut].iEps =0;

			// For alt setting, iterate eps

			for (altEp=1; altEp <= alt->iNumberOfEndpoints; altEp++)

				{

				__KTRACE_OPT(KUSB, Kern::Printf("Realize:     Endpoint to add: %d",altEp));

				TUsbcScEndpoint* nextEp = alt->iEndpoint[altEp];

				__KTRACE_OPT(KUSB, Kern::Printf("Realize:      ep Buffer Size: %d",nextEp->EndpointInfo()->iBufferSize));

				inout = (nextEp->EndpointInfo()->iDir==KUsbEpDirIn)?KUsbcScIn:

						(nextEp->EndpointInfo()->iDir==KUsbEpDirOut)?KUsbcScOut:KUsbcScUnknown;

				if (inout==KUsbcScUnknown)

					{

					__KTRACE_OPT(KUSB, Kern::Printf("Realize:     KUsbcScUnknown %x",nextEp->EndpointInfo()->iDir));

					return KErrArgument;

					}

				bufsd = &(iBufs[inout]);

				__KTRACE_OPT(KUSB, Kern::Printf("Realize:      ep direction: %x # endpoints %d", inout, bufsd->iEps));

				// find and position ep, and insert.

				if (bufsd->iEps==0) // First entry.

					{

					__KTRACE_OPT(KUSB, Kern::Printf("Realize:       Add first endpoint"));