// Copyright (c) 2008-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\usbcsc_bil.cpp
// 
//

#include <e32std.h>
#include <e32std_private.h>
#include <d32usbcsc.h>
#include <e32debug.h>

/** @file usbcsc_bil.cpp

	Buffer Interface Layer for USB Client Device driver stack, using shared chunks.

	@internalTechnology
*/

EXPORT_C TInt RDevUsbcScClient::FinalizeInterface()
	{
	TInt errorOrhandle = DoControl(EControlRealizeInterface); //returns a error value or chunk handle
	TInt r = iSharedChunk.SetReturnedHandle(errorOrhandle);
	iEndpointStatus = 0x00; //all endpoints are closed at the moment
	iAlternateSetting = 0;
	iNewAltSetting = 0;
	iAltSettingSeq = 0;
	return r;
	}


EXPORT_C TInt RDevUsbcScClient::FinalizeInterface(RChunk*& aChunk)
	{
	TInt errorOrhandle = DoControl(EControlRealizeInterface);
	iSharedChunk.SetReturnedHandle(errorOrhandle);
	iEndpointStatus = 0x00; //all endpoints are closed at the moment
	iAlternateSetting = 0;
	return aChunk->SetReturnedHandle(errorOrhandle);
	}


EXPORT_C TInt RDevUsbcScClient::OpenEndpoint(TEndpointBuffer& aEpB, TInt aEpI)
	{
	TUsbcScHdrEndpointRecord* endpointInf = NULL;
	TBuf8<KUsbDescSize_Endpoint> descriptor;
	TUsbcScChunkHeader chunkHeader(iSharedChunk);
	//Do some validity checks
	if((aEpB.iInState != TEndpointBuffer::ENotValid) && (aEpB.iOutState != TEndpointBuffer::ENotValid))
		return KErrArgument;

	TInt nEndpoints = chunkHeader.GetNumberOfEndpoints(iAlternateSetting);	
	if ((aEpI < KEp0Number) && (aEpI > nEndpoints)) // Check endpoint number range 
		return KErrNotFound;

	if(iEndpointStatus & (1 << aEpI)) // Check that endpoint isn't already opene
		return KErrInUse;

	if(aEpI == KEp0Number) //endpoint 0
		{
		TUsbcScHdrEndpointRecord ep0=  TUsbcScHdrEndpointRecord(KUsbcScEndpointZero, KUsbScHdrEpDirectionBiDir | KUsbScHdrEpTypeControl);
		aEpB.Construct(this,iSharedChunk.Base(), &ep0 ,aEpI, 
		(SUsbcScBufferHeader*) ((TUint)iSharedChunk.Base() + (chunkHeader.iBuffers)->Ep0Out()->Offset()));

		aEpB.iBufferStartAddr = (TUint8*) ((TUint)iSharedChunk.Base() + (chunkHeader.iBuffers)->Ep0In()->Offset());
		aEpB.iSize = chunkHeader.iBuffers->Ep0In()->Size();
		}
	else  // If normal endpoint (!ep0)
		{
		TUsbcScBufferRecord* buf = 	chunkHeader.GetBuffer(iAlternateSetting,aEpI,endpointInf);
		if (!buf)
			return KErrGeneral;
		// Set up endpoint members
		aEpB.iBufferStartAddr = (TUint8*)  (buf->Offset() + (TUint)iSharedChunk.Base());
		aEpB.iSize = buf->Size();
		TInt r = GetEndpointDescriptor(iAlternateSetting, aEpI, descriptor);
		if(r != KErrNone) // We need this to be able to calculate alignment
			{
			return r;
			}

		if (endpointInf->Direction()&KUsbScHdrEpDirectionIn)
			{  							//in case of IN endpoints, first endpoint buffer location points to end offset
			aEpB.Construct(this,iSharedChunk.Base(),endpointInf,aEpI);
			if (iInAltSetting==KErrEof)
			aEpB.iInState=TEndpointBuffer::EEOF;

			}
		else
			{
			SUsbcScBufferHeader *endpointHdr = (SUsbcScBufferHeader *) aEpB.iBufferStartAddr;
			//In this case,SUsbcScBufferHeader points to full OUT endpoint header 
			aEpB.Construct(this,iSharedChunk.Base(),endpointInf,aEpI, endpointHdr);
			}
		}
	iEndpointStatus |= (1 << aEpI);	

#ifdef _DEBUG
	aEpB.Dump();
	RDebug::Printf("iEndpointStatus: %x \n",iEndpointStatus);
#endif
	return KErrNone;
	}


//Internal, used by RDevUsbcScClient::StartNextOutAlternateSetting(...)
//This drains any old data from an OUT buffer, and gets it ready for reading an ep.
//aBufferOffset - The offset, into the chunk, that the buffer in question, may be found.
 
TInt RDevUsbcScClient::Drain(TUint aBufferOffset)
{
	TUint8* base = iSharedChunk.Base();
	SUsbcScBufferHeader* endpointHdr = (SUsbcScBufferHeader*) (aBufferOffset+base);
	TUint localTail = endpointHdr->iBilTail;
	TUsbcScTransferHeader* currentTransfer;
	TUint16 next = (iAltSettingSeq+1)&0xFFFF;
	TInt err=KErrNone;

	while (ETrue)
		{
		if (localTail == (TUint) endpointHdr->iHead)
			{
			err = KErrNotReady;
			break;
			}
		currentTransfer = (TUsbcScTransferHeader*) (base + localTail);

		if (currentTransfer->iAltSettingSeq == next)
			{
			iNewAltSetting=currentTransfer->iAltSetting; // record new alt setting
			break;
			}
		else
			{
			localTail = currentTransfer->iNext;
			}
		} // end while
	endpointHdr->iBilTail = localTail;
	endpointHdr->iTail = localTail;
	return err;
}

//Internal, used by RDevUsbcScClient::StartNextOutAlternateSetting(...)
//This method checks that the OUT buffer is ready for reading an ep.
//aBufferOffset - The offset, into the chunk, that the buffer in question, may be found.

TInt RDevUsbcScClient::Peek(TUint aBufferOffset)
{
	TUint8* base = iSharedChunk.Base();
	SUsbcScBufferHeader* endpointHdr = (SUsbcScBufferHeader*) (aBufferOffset+base);
	TUint localTail = endpointHdr->iBilTail;
	TUsbcScTransferHeader* currentTransfer = (TUsbcScTransferHeader*) (base + localTail);

	if ((localTail == (TUint)endpointHdr->iHead) || (currentTransfer->iAltSettingSeq != (iAltSettingSeq+1)&0xFFFF))
		// if alternate setting has not changed
		return KErrNotReady;
	else
		{
		iNewAltSetting=currentTransfer->iAltSetting;
		return KErrNone;
		}
}

//Internal, used by RDevUsbcScClient::StartNextOutAlternateSetting(...)
//This method is called if an alternate setting change happens from a set of ONLY IN endpoints.
//Used to find the least possible alternate setting it can return to the user, stored in iNewAltSetting
//Returns the sequence number of the 'latest' alternate setting it can switch to

TInt RDevUsbcScClient::FindNextAlternateSetting()
	{
	TUsbcScChunkHeader chunkHeader(iSharedChunk);
	TUsbcScHdrEndpointRecord* endpointInf = NULL;
	TUint bufOff;
	TInt altSet;
	TInt ep;
	TInt bufNum;

	RArray <TInt> bufferOffset;	// Array to contain all OUT enpoint buffer offsets
	// Populate array
	for (altSet = 0; altSet < chunkHeader.iAltSettings->iNumOfAltSettings ; altSet++)
		{
		TInt numEndpoints = chunkHeader.GetNumberOfEndpoints(altSet);
		for (ep =  1; ep  <= numEndpoints ; ep ++)
			{
			bufOff = chunkHeader.GetBuffer(altSet, ep, endpointInf)->Offset();	
			if ((endpointInf->Direction() & KUsbScHdrEpDirectionOut) && (bufferOffset.Find(bufOff) == KErrNotFound))
				{
				bufferOffset.Append(bufOff);
				}
			}
		}

	TInt err = KErrNotFound;
	TUint16 altSetSeqDelta = 0;
	TUint16 currentaltSetSeqDelta = 0;
	TBool noNewSettingFound = ETrue;
	TInt altSetSeq = iAltSettingSeq;
	TUint8* base = iSharedChunk.Base();

	for (bufNum = 0; bufNum < bufferOffset.Count(); bufNum++) // Scan all OUT buffers
		{	
		SUsbcScBufferHeader* endpointHdr = (SUsbcScBufferHeader*) (bufferOffset[bufNum] + base);
		TUint localTail = endpointHdr->iBilTail;
		TUsbcScTransferHeader* currentTransfer;
		TUint16 next = (iAltSettingSeq+1)&0xFFFF;
		
		while (ETrue)
			{
			if (localTail == (TUint) endpointHdr->iHead)
				{
				break;	// This OUT endpoint buffer has no data, proceed checking with other OUT endpoint buffers
				}
			currentTransfer = (TUsbcScTransferHeader*) (base + localTail);

			if (currentTransfer->iAltSettingSeq != iAltSettingSeq) 
				{
				if (currentTransfer->iAltSettingSeq == next)
					{
					altSetSeq = currentTransfer->iAltSettingSeq;
					iNewAltSetting = currentTransfer->iAltSetting; // record new alt setting
					err = KErrNone;
					break;
					}

				if (noNewSettingFound)
					{
					altSetSeqDelta = Abs(iAltSettingSeq - currentTransfer->iAltSettingSeq);
					altSetSeq = currentTransfer->iAltSettingSeq;
					iNewAltSetting = currentTransfer->iAltSetting; // record new alt setting
					noNewSettingFound = EFalse;
					}
				else
					{
					currentaltSetSeqDelta = Abs(iAltSettingSeq - currentTransfer->iAltSettingSeq);
					if (currentaltSetSeqDelta < altSetSeqDelta)
						{
						altSetSeqDelta = currentaltSetSeqDelta;
						altSetSeq = currentTransfer->iAltSettingSeq;
						iNewAltSetting = currentTransfer->iAltSetting;
						}
					}
				break;
				}
			
			localTail = currentTransfer->iNext;
			} // end while

		if (!err) // Found an alt set sequence one after iAltSettingSeq
			{
			break; // found 'the next' alternate setting, exit for loop
			}
		
		}// for loop

	return altSetSeq;
	}

EXPORT_C TInt RDevUsbcScClient::StartNextOutAlternateSetting(TBool aFlush)
	{
	TUsbcScChunkHeader chunkHeader(iSharedChunk);
	
	//if endpoints are still open, return KErrInUse 
	if((iEndpointStatus&~1) != 0)
		{
		return KErrInUse;
		}

	TInt r;
	TInt ep;
	TInt noEp;
	TUint bufOff;
	TBool inEndpointSet = ETrue;
	TUsbcScHdrEndpointRecord* endpointInf = NULL;

	// check if alternate setting contains all IN endpoints
	noEp = chunkHeader.GetNumberOfEndpoints(iAlternateSetting);

	// for each used buffer. 
	for (ep=1;ep<=noEp;ep++)
		{
		bufOff = chunkHeader.GetBuffer(iAlternateSetting,ep,endpointInf)->Offset();	
	
		if (endpointInf->Direction() & KUsbScHdrEpDirectionOut) 
			{
			inEndpointSet = EFalse;
			if (aFlush)
				r = Drain(bufOff); // we need to remove anythng in the way, and get it ready for reading.
			else
				r = Peek(bufOff); // we need to check it is ready for reading!
			if (r) 
				return r;
			}
		}


	TInt altSeq = 0;
	if (inEndpointSet)	// If all endpoints in the current alternate setting are IN endpoints
		{	// go through all OUT buffers for alternate setting change
		altSeq = FindNextAlternateSetting();
		}

	if((iNewAltSetting == iAlternateSetting) && (!inEndpointSet))
			{
			return KErrNotReady;
			}

	// Find/Set IN alternate setting
	TInt ret = StartNextInAlternateSetting();
	SUsbcScAlternateSetting* altrec = ((SUsbcScAlternateSetting*) (&ret));

	if (altrec->iSequence==iAltSettingSeq+1)
		{
		if (altrec->iSetting!=iNewAltSetting)
			return KErrGeneral;
		iInAltSetting=iNewAltSetting;
		}
	else
		{
		if (inEndpointSet)
			{
			if ((altSeq == iAltSettingSeq) || (iAltSettingSeq == altrec->iSequence))
				{
				return KErrNotReady;
				}
			else if (altSeq != altrec->iSequence)
				{
				iInAltSetting=KErrEof;
				}
			}
		iInAltSetting=KErrEof;
		}

	iAlternateSetting = iNewAltSetting;
	iAltSettingSeq += 1;

	return iAlternateSetting;
	}


EXPORT_C TInt RDevUsbcScClient::GetDataTransferChunk(RChunk* & aChunk)
	{
	aChunk = &iSharedChunk;
	return KErrNone;
	}

// Constructor

EXPORT_C TEndpointBuffer::TEndpointBuffer()
		:iInState(ENotValid),
		iOutState(ENotValid),
		iEndpointNumber(-1),
		iBufferNum(-1),
		iBufferStartAddr(0),
		iSize(0)
	{
	}

// Internal, called by RDevUsbcScClient::OpenEndpoint.
void TEndpointBuffer::Construct(RDevUsbcScClient* aClient, TUint8* aBaseAddr, const TUsbcScHdrEndpointRecord* aEpType , TInt aEndpointNumber,SUsbcScBufferHeader* aEndpointHdr)
	{
	iClient		= aClient;
	iBaseAddr	= (TUint) aBaseAddr;
	iInState 	= (((aEpType->Direction())&KUsbScHdrEpDirectionIn) ? EValid :  ENotValid);
	iOutState	= (((aEpType->Direction())&KUsbScHdrEpDirectionOut) ? EValid :  ENotValid);
	iBufferNum	= (aEpType->iBufferNo==(KUsbcScEndpointZero&0xFF))?KUsbcScEndpointZero:aEpType->iBufferNo;
	iEndpointNumber = aEndpointNumber;

	iEndpointHdr = aEndpointHdr;
	};

EXPORT_C TInt TEndpointBuffer::GetInBufferRange(TAny*& aStart, TUint& aSize)
	{
	if ((iInState))
		{
		return iInState;
		}
	aStart= iBufferStartAddr;
	aSize= iSize;
	return KErrNone;
	};

EXPORT_C TInt TEndpointBuffer::GetInBufferRange(TUint& aStart, TUint& aSize)
	{
	if ((iInState))
		return iInState;
	aStart=	(TUint) iBufferStartAddr - iBaseAddr;
	aSize= iSize;
	return KErrNone;
	}


EXPORT_C TInt TEndpointBuffer::GetBuffer(TAny*& aBuffer,TUint& aSize,TBool& aZLP,TRequestStatus& aStatus,TUint aLength)
	{
	if (iOutState)
		return iOutState;

	TUsbcScTransferHeader* currentTransfer;
	TInt r;
	do // until we have a transfer with data.
		{
		iEndpointHdr->iTail = iEndpointHdr->iBilTail; 
		if(iEndpointHdr->iBilTail == iEndpointHdr->iHead)  //If no new data, create request
			{
			r = iClient->ReadDataNotify(iBufferNum,aStatus);
			if (r!=KErrCompletion)  // Data could arrive since we checked.
				return r;
			}
		currentTransfer = (TUsbcScTransferHeader*) (iBaseAddr + iEndpointHdr->iBilTail);

		iEndpointHdr->iBilTail = currentTransfer->iNext;
		aZLP = (currentTransfer->iFlags & KUsbcScShortPacket)!=EFalse;

		if(currentTransfer->iAltSettingSeq != (iClient->iAltSettingSeq))  // if alternate setting has changed
			{
			if (currentTransfer->iAltSettingSeq == (iClient->iAltSettingSeq+1))	   //Note- KIS ATM, if multiple alternate setting changes happen
				iClient->iNewAltSetting = currentTransfer->iAltSetting; //before StartNextOutAlternateSetting is called, 		   
																	   //this variable will reflect the latest requested AlternateSetting


			if (iEndpointNumber != KEp0Number)
				{
//				iOutState =  EEOF;	
				return KErrEof;
				}
			else if ((currentTransfer->iBytes==0) && (!aZLP)) 
				{
				return KErrAlternateSettingChanged;
				}
			}						

		}
	while ((currentTransfer->iBytes==0) && (!aZLP)); // ignore empty transfers

	aBuffer = currentTransfer->iData.i;
	aSize = currentTransfer->iBytes;	
	return (currentTransfer->iFlags & KUsbcScStateChange)?KStateChange:KErrCompletion;	
	}

EXPORT_C TInt TEndpointBuffer::TakeBuffer(TAny*& aBuffer,TUint& aSize,TBool& aZLP,TRequestStatus& aStatus,TUint aLength)
	{
	if (iOutState)
		return iOutState;

	TUsbcScTransferHeader* currentTransfer;
	TInt r;
	do // until we have a transfer with data.
		{
		if(iEndpointHdr->iBilTail == iEndpointHdr->iHead)  //If no new data, create request
			{
			r = iClient->ReadDataNotify(iBufferNum,aStatus);
			if (r!=KErrCompletion)  // Data could arrive since we checked.
				{
				return r;
				}
			}

		currentTransfer = (TUsbcScTransferHeader*) (iBaseAddr + iEndpointHdr->iBilTail);
		iEndpointHdr->iBilTail = currentTransfer->iNext;
		aZLP = (currentTransfer->iFlags & KUsbcScShortPacket)!=EFalse; // True if short packet else false 

		if(currentTransfer->iAltSettingSeq != (iClient->iAltSettingSeq))  // if alternate setting has changed
			{
			if (currentTransfer->iAltSettingSeq == (iClient->iAltSettingSeq+1))	   //Note- KIS ATM, if multiple alternate setting changes happen
				iClient->iNewAltSetting = currentTransfer->iAltSetting; //before StartNextOutAlternateSetting is called, 		   
																	   //this variable will reflect the latest requested AlternateSetting
			Expire(currentTransfer->iData.i);
			if (iEndpointNumber != KEp0Number)
				{
//				iOutState = EEOF;
				return KErrEof;
				}
			else if ((currentTransfer->iBytes==0) && (!aZLP)) 
				{
				return KErrAlternateSettingChanged;
				}

			}	

		if ((currentTransfer->iBytes==0) && (!aZLP)) // here , if empty transfer with alt setting information, Call expire 
			{
			Expire(currentTransfer->iData.i);
			}
		}
	while ((currentTransfer->iBytes==0) && (!aZLP)); // ignore empty transfers

	aBuffer = currentTransfer->iData.i;
	aSize = currentTransfer->iBytes;
	return (currentTransfer->iFlags & KUsbcScStateChange)?KStateChange:KErrCompletion;	
	}

EXPORT_C TInt TEndpointBuffer::Expire()
	{
	if (!(iOutState != ENotValid))
		return iOutState;

	if (iEndpointHdr->iTail != iEndpointHdr->iBilTail)
		{
		TUsbcScTransferHeader* currentTransfer = (TUsbcScTransferHeader*) (iBaseAddr + iEndpointHdr->iTail);
		iEndpointHdr->iTail = currentTransfer->iNext;
		}
	return KErrNone;
	}

EXPORT_C TInt TEndpointBuffer::Expire(TAny* aAddress)
	{
	if (!(iOutState != ENotValid))
		return iOutState;

	TUint headerSize = sizeof(TUsbcScTransferHeader)-4; // TransferHeader includes 4 bytes of data.
	TInt transferToExpire = ((TUint) aAddress - headerSize);
	TInt offsetToExpire = transferToExpire - iBaseAddr; 

	TInt currentTail = iEndpointHdr->iTail;

	TInt prevTail = NULL;
	TBool found = EFalse;
	while (currentTail != iEndpointHdr->iBilTail)
		{
		TUsbcScTransferHeader* currentTransfer = (TUsbcScTransferHeader*) (iBaseAddr + currentTail);
		if (currentTail == offsetToExpire)		// found which to expire
			{
			found = ETrue;
			// This offset is to be expired
			if (prevTail == NULL)
				{
				// The offset is at the list head
				iEndpointHdr->iTail = currentTransfer->iNext;	
				}
			else
				{
				// The offset is NOT at the list head
				// This leaves a GAP in the buffer which will not be filled unless the 'transfers' before 'currentTail' are expired
				currentTail = currentTransfer->iNext;
				TUsbcScTransferHeader* prevTransfer = (TUsbcScTransferHeader*) (iBaseAddr + prevTail);
				prevTransfer->iNext = currentTail;
				}
			break;
			}
		prevTail = currentTail;
		currentTail = currentTransfer->iNext;
		}
	return found ? KErrNone : KErrNotFound;
	}

	
EXPORT_C TInt TEndpointBuffer::WriteBuffer(TAny* aBuffer,TUint aSize,TBool aZLP,TRequestStatus& aStatus)
	{
	if (iInState)
		return iInState;

	iClient->WriteData(iBufferNum, ((TUint)aBuffer - (TUint)iBaseAddr),aSize,aZLP,aStatus);
	return KErrNone;
	}


EXPORT_C TInt TEndpointBuffer::WriteBuffer(TUint aOffset,TUint aSize,TBool aZLP,TRequestStatus& aStatus)
	{
	if (iInState)
		return iInState;

	iClient->WriteData(iBufferNum,aOffset,aSize,aZLP,aStatus);
	return KErrNone;
	}


/**
Closes the endpoint buffer
@return			KErrNone if close is successfull
*/	
EXPORT_C TInt TEndpointBuffer::Close()
	{
	if ((iInState == ENotValid) && (iOutState == ENotValid))
		return KErrNotFound;
	if (iOutState != ENotValid)
		{
		TUsbcScTransferHeader* currentTransfer = (TUsbcScTransferHeader*) (iBaseAddr + iEndpointHdr->iTail);
		//Incase of AlternateSetting changes and using TEndpointBuffer::GetBuffer, iTail is always one 'transfer' behind iBilTail
		//Incase of AlternateSetting changes and using TEndpointBuffer::TakeBuffer, this shuold force the user to update iTail & only then closes the endpoint buffer
		if (((TInt) currentTransfer->iNext != iEndpointHdr->iBilTail) && (iEndpointHdr->iTail != iEndpointHdr->iBilTail))
			return KErrNotReady;
		}
	iClient->iEndpointStatus &= ~(1 << iEndpointNumber); //reset the bit corresponding to endpoint
	iInState = ENotValid;
	iOutState = ENotValid;
	return KErrNone;
	}


  
EXPORT_C TUsbcScChunkHeader::TUsbcScChunkHeader(RChunk aChunk)
	{
	iChunk = aChunk;
	iBuffers     = (TUsbcScChunkBuffersHeader*)    (aChunk.Base()+((TUsbcScChunkHdrOffs*)iChunk.Base())->iBuffers);
	iAltSettings = (TUsbcScChunkAltSettingHeader*) (aChunk.Base()+((TUsbcScChunkHdrOffs*)iChunk.Base())->iAltSettings);
	}

EXPORT_C TInt TUsbcScChunkHeader::GetNumberOfEndpoints(TInt aAltSetting)
	{
	if ((aAltSetting<0) || (aAltSetting>=iAltSettings->iNumOfAltSettings))
		return KErrArgument;
	return  *((TInt*) (iAltSettings->iAltTableOffset[aAltSetting] + (TInt) iChunk.Base()));
	}


EXPORT_C TUsbcScBufferRecord* TUsbcScChunkHeader::GetBuffer(TInt aAltSetting, TInt aEndpoint, TUsbcScHdrEndpointRecord*& aEndpointInf)
	{
	if ((aAltSetting<0) || (aAltSetting>=iAltSettings->iNumOfAltSettings))
		return NULL;
	TInt8* iEndpoint = (TInt8*) (iAltSettings->iAltTableOffset[aAltSetting] + (TInt) iChunk.Base());
	if ((aEndpoint<=0) || (aEndpoint>*iEndpoint))
		return NULL;
	aEndpointInf = (TUsbcScHdrEndpointRecord*) &(iEndpoint[aEndpoint*iAltSettings->iEpRecordSize]);
	return iBuffers->Buffers(aEndpointInf->iBufferNo);
	}


/* Debug functions */

EXPORT_C void TEndpointBuffer::Dump()
	{
	RDebug::Printf("TEndpointBuffer::Dump iBufferStart: 0x%x, iSize: 0x%x, iEndpointNumber: 0x%x, iBufferNum: %d, iInState: 0x%x iOutState: 0x%x\n",
							iBufferStartAddr,iSize,iEndpointNumber,iBufferNum,iInState,iOutState);
	}

