// Copyright (c) 2007-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:

//

#include "zerocopytransferstrategy.h"

#include <d32usbtransfers.h>

#include <d32usbdi.h>

#include <d32usbdi_errors.h>

#include "zerocopymetadata.h"

#include "usbdiutils.h"

RUsbZeroCopyTransferStrategy::TUsbTransferDescriptorDetails::TUsbTransferDescriptorDetails(RUsbTransferDescriptor& aTransferDesc, TInt aRequiredSize, TUint aRequiredAlignment, TInt aRequiredMaxPackets)

	: iTransferDesc(aTransferDesc)

	, iRequiredSize(aRequiredSize)

	, iRequiredAlignment(aRequiredAlignment)

	, iRequiredMaxPackets(aRequiredMaxPackets)

	{

	}

RUsbZeroCopyTransferStrategy::RUsbZeroCopyTransferStrategy()

	: iInterfaceHandle(NULL)

	{

	}

void RUsbZeroCopyTransferStrategy::Close()

	{

	iInterfaceHandle = NULL;

	iChunk.Close();

	iRegisteredTransfers.Close();

	RUsbTransferStrategy::Close();

	}

TInt RUsbZeroCopyTransferStrategy::RegisterTransferDescriptor(RUsbTransferDescriptor& aTransferDesc, TInt aRequiredSize, TUint aStartAlignment, TInt aRequiredMaxPackets)

	{

	__ASSERT_ALWAYS(!iInterfaceHandle, UsbdiUtils::Panic(UsbdiPanics::ETransferDescriptorsAlreadyRegistered));

	if (iRegisteredTransfers.Find(aTransferDesc, CompareTransferDescriptor) != KErrNotFound)

		{

		return KErrAlreadyExists;

		}

	return iRegisteredTransfers.Append(TUsbTransferDescriptorDetails(aTransferDesc, aRequiredSize, aStartAlignment, aRequiredMaxPackets));

	}

TBool RUsbZeroCopyTransferStrategy::CompareTransferDescriptor(const RUsbTransferDescriptor* aTransferDesc, const TUsbTransferDescriptorDetails& aDetails)

	{

	return aTransferDesc == &aDetails.iTransferDesc;

	}

void RUsbZeroCopyTransferStrategy::ResetTransferDescriptors()

	{

	__ASSERT_ALWAYS(!iInterfaceHandle, UsbdiUtils::Panic(UsbdiPanics::ETransferDescriptorsAlreadyRegistered));

	iRegisteredTransfers.Reset();

	}

TInt RUsbZeroCopyTransferStrategy::InitialiseTransferDescriptors(RUsbInterface& aInterface)

	{

	__ASSERT_ALWAYS(!iInterfaceHandle, UsbdiUtils::Panic(UsbdiPanics::ETransferDescriptorsAlreadyRegistered));

	// This is the equivilent of a standard R-class Open() method, so initialise the references

	// we are going to use.

	iInterfaceHandle = &aInterface;

	// First get the page-size as we will need this for isoc transfer calculations.

	TInt hcdPageSize = 0;

	TInt err = aInterface.GetHcdPageSize(hcdPageSize);

	if (err != KErrNone)

		{

		Close(); // roll back

		return err;

		}

	iPageSize = hcdPageSize;

	TInt currentOffset = 0;

	TInt numStandardTransfers = 0;

	TInt numIsocTransfers = 0;

	TInt numIsocElements = 0;

	err = CalculateDataLayout(currentOffset, numStandardTransfers, numIsocTransfers, numIsocElements);

	if (err != KErrNone)

		{

		Close(); // roll back

		return err;

		}

	TInt metaDataStart = 0;

	CalculateMetaDataLayout(currentOffset, metaDataStart, numStandardTransfers, numIsocTransfers, numIsocElements);

	// currentOffset should now be just past the region required for all the data and meta data.

	// Therefore it equals the total size of the buffer we need to hold them all.

	err = iInterfaceHandle->AllocateSharedChunk(iChunk, currentOffset, iBaseOffset);

	if (err != KErrNone)

		{

		Close(); // roll back

		return err;

		}

	InitialiseMetaData(metaDataStart, numStandardTransfers, numIsocTransfers, numIsocElements);

	return KErrNone;

	}

TInt RUsbZeroCopyTransferStrategy::CalculateDataLayout(TInt& aCurrentOffset, TInt& aNumStandardTransfers, TInt& aNumIsocTransfers, TInt& aNumIsocElements)

	{

	const TUint32 pageAddrBits = iPageSize-1;

	const TUint32 pageTableMask = ~pageAddrBits;

	//Get the maximum wMaxPacketSize of the associated interface for Bulk/Interrupt EPs

	TInt maxMaxBulk = 0;

	TInt maxMaxInterrupt = 0;

	TInt err = GetMaximumMaxPacketSize(maxMaxBulk, maxMaxInterrupt);

	if (err != KErrNone)

		{

		return err;

		}

	// Work out where to place the transfers, and how much space is needed.

	TInt numTransfers = iRegisteredTransfers.Count();

	for (TInt i=0; i < numTransfers; ++i)

		{

		TUsbTransferDescriptorDetails& details = iRegisteredTransfers[i];

		err = CaculateAdditionalAlignment(aCurrentOffset, maxMaxBulk, maxMaxInterrupt, details);

		if (err != KErrNone)

			{

			return err;

			}

		// only allow intra-page alignment requests that are powers of 2 (so offset agnostic).

		__ASSERT_ALWAYS(details.iRequiredAlignment <= iPageSize, UsbdiUtils::Panic(UsbdiPanics::ETransferDescriptorAlignmentOverPageBoundary));

		__ASSERT_ALWAYS(IsPowerOfTwo(details.iRequiredAlignment), UsbdiUtils::Panic(UsbdiPanics::ETransferDescriptorAlignmentNotPowerOfTwo));

		TInt alignPad = IncNeededToAlign(aCurrentOffset, details.iRequiredAlignment);

		__ASSERT_DEBUG(alignPad < iPageSize, UsbdiUtils::Fault(UsbdiFaults::EUsbTransferDescriptorBadAlignment)); // just re-asserting what should be guarded above

		aCurrentOffset += alignPad; // Align to the start of transfer buffer

		// There are stark differences between isoc transfers and transfer of other types.

		if (details.iTransferDesc.iType == RUsbTransferDescriptor::EIsochronous)

			{

			// First do some Isoc specific checks

			__ASSERT_ALWAYS(details.iRequiredMaxPackets > 0, UsbdiUtils::Panic(UsbdiPanics::ETransferDescriptorNoPacketsRequested));

			// For the allocation we have to consider the worse case - that is that the max

			// number of packets at the max packet size.

			// We are constrained by the USB stack to not allow transfers across page boundaries.

			// As such we calculate how many packets we can fit into a page to determine the

			// number of pages for data we need.

			const TInt packetsPerPage = iPageSize/details.iRequiredSize;

			// Assign the start to an appropriate point.

			details.iAssignedOffset = aCurrentOffset;

			TInt packetsToStore = details.iRequiredMaxPackets;

			TInt numElements = 0; // for counting up the number of pages we need meta-data for.

			// The size requried to hold a length array for the descriptor

			const TInt lengthsArrayLength = UsbZeroCopyIsocChunkHeader::KLengthsElementSize * details.iRequiredMaxPackets;

			// The size required to hold a result array for the descriptor

			const TInt resultsArrayLength = UsbZeroCopyIsocChunkHeader::KResultsElementSize * details.iRequiredMaxPackets;

			// Determine how much we can fit into the remaining space of the current page.

			TBool samePage = (pageTableMask & aCurrentOffset) == (pageTableMask & (aCurrentOffset - alignPad));

			if (samePage)

				{

				TInt remainingSpace = iPageSize - (pageAddrBits & aCurrentOffset);

				TInt packetsThatFit = remainingSpace / details.iRequiredSize;

				if (packetsThatFit >= packetsToStore)

					{

					// We can fit it in this page so we finish here - this is the special case.

					aCurrentOffset += packetsToStore * details.iRequiredSize;

					++aNumIsocElements;

					++aNumIsocTransfers;

					details.iNumElements = 1;

					// Do the lengths array

					aCurrentOffset += IncNeededToAlign(aCurrentOffset, UsbZeroCopyIsocChunkHeader::KLengthsElementSize);

					details.iLengthsOffset = aCurrentOffset;

					aCurrentOffset += lengthsArrayLength;

					// The dual lengths array should be implicitly alligned

					details.iReqLenOffset = aCurrentOffset;

					aCurrentOffset += lengthsArrayLength;

					// Now handle the results array

					aCurrentOffset += IncNeededToAlign(aCurrentOffset, UsbZeroCopyIsocChunkHeader::KResultsElementSize);

					details.iResultsOffset = aCurrentOffset;

					aCurrentOffset += resultsArrayLength;

					continue;

					}

				aCurrentOffset = (pageTableMask & aCurrentOffset) + iPageSize; // Advance to next page

				packetsToStore -= packetsThatFit;

				++numElements;

				}

			__ASSERT_DEBUG(packetsToStore > 0, UsbdiUtils::Fault(UsbdiFaults::EUsbTransferDescriptorNoPacketsLeftToStore));

			// Determine the number of pages extra that are needed (minus one)

			TInt pagesRequired = packetsToStore / packetsPerPage;

			// Determine how much of the last page is actually needed.

			TInt trailingPackets = packetsToStore % packetsPerPage;

			TInt usedSpace = trailingPackets * details.iRequiredSize;

			// Commit the amount for the buffers.

			aCurrentOffset += usedSpace + pagesRequired*iPageSize;

			numElements += pagesRequired + /*the final page*/1; // We have already included the first page (if already partially used)

			aNumIsocElements += numElements;

			++aNumIsocTransfers;

			// Used to ensure only allocate an appropriate number per-descriptor.

			details.iNumElements = numElements;

			// We also need an array of lengths for each packet that we use (need to align to even bytes).

			aCurrentOffset += IncNeededToAlign(aCurrentOffset, UsbZeroCopyIsocChunkHeader::KLengthsElementSize);

			details.iLengthsOffset = aCurrentOffset;

			aCurrentOffset += lengthsArrayLength;

			// Dual length array should be implicitly aligned

			details.iReqLenOffset = aCurrentOffset;

			aCurrentOffset += lengthsArrayLength;

			// Now handle the results array

			aCurrentOffset += IncNeededToAlign(aCurrentOffset, UsbZeroCopyIsocChunkHeader::KResultsElementSize);

			details.iResultsOffset = aCurrentOffset;

			aCurrentOffset += resultsArrayLength;

			}

		else

			{

			details.iAssignedOffset = aCurrentOffset;

			aCurrentOffset += details.iRequiredSize;

			++aNumStandardTransfers;

			}

		}

	return KErrNone;

	}

void RUsbZeroCopyTransferStrategy::CalculateMetaDataLayout(TInt& aCurrentOffset, TInt& aMetaDataStart, TInt aNumStandardTransfers, TInt aNumIsocTransfers, TInt aNumIsocElements)

	{

	// Round up to 4 byte alignment for handling the meta-data correctly.

	aCurrentOffset += IncNeededToAlign(aCurrentOffset, sizeof(TInt));

	aMetaDataStart = aCurrentOffset;

	// Now calculate the size required for the transfer meta-data.

	aCurrentOffset += aNumStandardTransfers * UsbZeroCopyBulkIntrChunkHeader::HeaderSize();

	aCurrentOffset += aNumIsocTransfers * UsbZeroCopyIsocChunkHeader::HeaderSize();

	aCurrentOffset += aNumIsocElements * UsbZeroCopyIsocChunkElement::ElementSize();

	}

void RUsbZeroCopyTransferStrategy::InitialiseMetaData(TInt aMetaDataOffset, TInt aNumStandardTransfers, TInt aNumIsocTransfers, TInt aNumIsocElements)

	{

	const TUint32 pageAddrBits = iPageSize-1;

	const TUint32 pageTableMask = ~pageAddrBits;

	TUint8* chunkBase = iChunk.Base() + iBaseOffset;

	TInt numTransfers = iRegisteredTransfers.Count();

	for (TInt i=0; i < numTransfers; ++i)

		{

		TUsbTransferDescriptorDetails details = iRegisteredTransfers[i];

		if (details.iTransferDesc.iType == RUsbTransferDescriptor::EIsochronous)

			{

			// Initialise Meta-data (minus elements).

			UsbZeroCopyIsocChunkHeader::TransferType(chunkBase, aMetaDataOffset) = details.iTransferDesc.iType;

			UsbZeroCopyIsocChunkHeader::MaxNumPackets(chunkBase, aMetaDataOffset) = details.iRequiredMaxPackets;

			UsbZeroCopyIsocChunkHeader::MaxPacketSize(chunkBase, aMetaDataOffset) = details.iRequiredSize;

			// Double check that the length array is aligned correctly.

			__ASSERT_DEBUG(details.iLengthsOffset % UsbZeroCopyIsocChunkHeader::KLengthsElementSize == 0,

				UsbdiUtils::Fault(UsbdiFaults::EUsbTransferDescriptorLengthsArrayBadAlignment));

			UsbZeroCopyIsocChunkHeader::LengthsOffset(chunkBase, aMetaDataOffset) = details.iLengthsOffset;

			UsbZeroCopyIsocChunkHeader::ReqLenOffset(chunkBase, aMetaDataOffset) = details.iReqLenOffset;

			// Double check that the result array is aligned correctly.

			__ASSERT_DEBUG(details.iResultsOffset % UsbZeroCopyIsocChunkHeader::KResultsElementSize == 0,

				UsbdiUtils::Fault(UsbdiFaults::EUsbTransferDescriptorResultsArrayBadAlignment));

			UsbZeroCopyIsocChunkHeader::ResultsOffset(chunkBase, aMetaDataOffset) = details.iResultsOffset;

			// Initialise transfer descriptor

			SetTransferHandle(details.iTransferDesc, aMetaDataOffset);

			// Move on to next meta-data slot

			TInt prevMetaOffset = aMetaDataOffset;

			aMetaDataOffset += UsbZeroCopyIsocChunkHeader::HeaderSize();

			// Initialise elements for transfers

			UsbZeroCopyIsocChunkHeader::FirstElementOffset(chunkBase, prevMetaOffset) = aMetaDataOffset;

			TInt isocElementsUnmapped = details.iNumElements;

			// First element could be anywhere, the others are at the start of (virtually) contiguous pages

			TInt offset = details.iAssignedOffset;

			while (isocElementsUnmapped > 0)

				{

				// Update the data references

				UsbZeroCopyIsocChunkElement::DataOffset(chunkBase, aMetaDataOffset) = offset;

				UsbZeroCopyIsocChunkElement::NumPackets(chunkBase, aMetaDataOffset) = 0; // Default value.

				// Move on to the next element and bind it to the chain.

				prevMetaOffset = aMetaDataOffset;

				aMetaDataOffset += UsbZeroCopyIsocChunkElement::ElementSize();

				UsbZeroCopyIsocChunkElement::NextElementOffset(chunkBase, prevMetaOffset) = aMetaDataOffset;

				// Move to the next page

				offset = (pageTableMask&offset)+iPageSize;

				--isocElementsUnmapped;

				--aNumIsocElements;

				}

			// We have reached the end of the list so we should update the next element offset for the

			// last element to indicate that it is the terminator.

			UsbZeroCopyIsocChunkElement::NextElementOffset(chunkBase, prevMetaOffset) = UsbZeroCopyIsocChunkElement::KEndOfList;

			--aNumIsocTransfers;

			}

		else

			{

			// Initialise Meta-data.

			UsbZeroCopyBulkIntrChunkHeader::TransferType(chunkBase, aMetaDataOffset) = details.iTransferDesc.iType;

			UsbZeroCopyBulkIntrChunkHeader::DataOffset(chunkBase, aMetaDataOffset) = details.iAssignedOffset;

			UsbZeroCopyBulkIntrChunkHeader::DataLength(chunkBase, aMetaDataOffset) = 0;

			UsbZeroCopyBulkIntrChunkHeader::DataMaxLength(chunkBase, aMetaDataOffset) = details.iRequiredSize;

			UsbZeroCopyBulkIntrChunkHeader::ZlpStatus(chunkBase, aMetaDataOffset) = RUsbTransferDescriptor::ESendZlpIfRequired;

			// Initialise transfer descriptor

			SetTransferHandle(details.iTransferDesc, aMetaDataOffset);

			// Move on to next meta-data slot

			aMetaDataOffset += UsbZeroCopyBulkIntrChunkHeader::HeaderSize();

			--aNumStandardTransfers;

			}

		}

	__ASSERT_DEBUG(aNumStandardTransfers == 0, UsbdiUtils::Fault(UsbdiFaults::EUsbTransferDescriptorIncompleteInitialisation));

	__ASSERT_DEBUG(aNumIsocTransfers == 0, UsbdiUtils::Fault(UsbdiFaults::EUsbTransferDescriptorIncompleteInitialisation));

	__ASSERT_DEBUG(aNumIsocElements == 0, UsbdiUtils::Fault(UsbdiFaults::EUsbTransferDescriptorIncompleteInitialisation));

	}

TBool RUsbZeroCopyTransferStrategy::IsPowerOfTwo(TUint aNumber)

	{

    return aNumber && !(aNumber & (aNumber - 1)); //this returns true if the integer is a power of two

    }

TInt RUsbZeroCopyTransferStrategy::IncNeededToAlign(TInt aOffset, TUint aAlignment)

	{

	if (aAlignment == 0)

		{

		return 0;

		}

	TInt remain = aOffset % aAlignment;

	return (aAlignment - remain) % aAlignment;

	}

// Standard Methods

TPtr8 RUsbZeroCopyTransferStrategy::WritableBuffer(TInt aHandle)

	{

	__ASSERT_DEBUG(aHandle >= 0, UsbdiUtils::Fault(UsbdiFaults::EUsbTransferDescriptorBadHandle));

	TUint8* chunkBase = iChunk.Base() + iBaseOffset;

	TUint8* dataPtr = chunkBase + UsbZeroCopyBulkIntrChunkHeader::DataOffset(chunkBase, aHandle);

	TInt maxLength = UsbZeroCopyBulkIntrChunkHeader::DataMaxLength(chunkBase, aHandle);

	return TPtr8(dataPtr, 0, maxLength);

	}

void RUsbZeroCopyTransferStrategy::SaveData(TInt aHandle, TInt aLength)

	{

	__ASSERT_DEBUG(aHandle >= 0, UsbdiUtils::Fault(UsbdiFaults::EUsbTransferDescriptorBadHandle));

	TUint8* chunkBase = iChunk.Base() + iBaseOffset;

	TInt maxLength = UsbZeroCopyBulkIntrChunkHeader::DataMaxLength(chunkBase, aHandle);

	__ASSERT_ALWAYS(aLength <= maxLength, UsbdiUtils::Panic(UsbdiPanics::ETransferDescriptorSavedToMuchData));

	UsbZeroCopyBulkIntrChunkHeader::DataLength(chunkBase, aHandle) = aLength;

	}

void RUsbZeroCopyTransferStrategy::SetZlpStatus(TInt aHandle, RUsbTransferDescriptor::TZlpStatus aZlpStatus)

	{

	__ASSERT_DEBUG(aHandle >= 0, UsbdiUtils::Fault(UsbdiFaults::EUsbTransferDescriptorBadHandle));

	TUint8* chunkBase = iChunk.Base() + iBaseOffset;

	UsbZeroCopyBulkIntrChunkHeader::ZlpStatus(chunkBase, aHandle) = aZlpStatus;

	}

TPtrC8 RUsbZeroCopyTransferStrategy::Buffer(TInt aHandle) const

	{

	__ASSERT_DEBUG(aHandle >= 0, UsbdiUtils::Fault(UsbdiFaults::EUsbTransferDescriptorBadHandle));

	TUint8* chunkBase = iChunk.Base() + iBaseOffset;

	TUint8* dataPtr = chunkBase + UsbZeroCopyBulkIntrChunkHeader::DataOffset(chunkBase, aHandle);

	TInt length = UsbZeroCopyBulkIntrChunkHeader::DataLength(chunkBase, aHandle);

	return TPtrC8(dataPtr, length);

	}

// Isochronous Methods

void RUsbZeroCopyTransferStrategy::Reset(TInt aHandle)

	{

	__ASSERT_DEBUG(aHandle >= 0, UsbdiUtils::Fault(UsbdiFaults::EUsbTransferDescriptorBadHandle));

	TUint8* chunkBase = iChunk.Base() + iBaseOffset;

	// Loop through and reset number of packets in each element as 0

	TInt elementOffset = UsbZeroCopyIsocChunkHeader::FirstElementOffset(chunkBase, aHandle);

	while (elementOffset != UsbZeroCopyIsocChunkElement::KEndOfList)

		{

		UsbZeroCopyIsocChunkElement::NumPackets(chunkBase, elementOffset) = 0;

		elementOffset = UsbZeroCopyIsocChunkElement::NextElementOffset(chunkBase, elementOffset);

		}

	}

TPacketLengths RUsbZeroCopyTransferStrategy::Lengths(TInt aHandle)

	{

	__ASSERT_DEBUG(aHandle >= 0, UsbdiUtils::Fault(UsbdiFaults::EUsbTransferDescriptorBadHandle));

	TUint8* chunkBase = iChunk.Base() + iBaseOffset;

	TInt lengthsOffset = UsbZeroCopyIsocChunkHeader::LengthsOffset(chunkBase, aHandle);

	TUint16* lengthsPtr = reinterpret_cast<TUint16*>(chunkBase + lengthsOffset);

	TInt reqLenOffset = UsbZeroCopyIsocChunkHeader::ReqLenOffset(chunkBase, aHandle);

	TUint16* reqLenPtr = reinterpret_cast<TUint16*>(chunkBase + reqLenOffset);

	TInt& maxNumPackets = UsbZeroCopyIsocChunkHeader::MaxNumPackets(chunkBase, aHandle);

	return TPacketLengths(lengthsPtr, reqLenPtr, maxNumPackets);

	}

TPacketResults RUsbZeroCopyTransferStrategy::Results(TInt aHandle)

	{

	__ASSERT_DEBUG(aHandle >= 0, UsbdiUtils::Fault(UsbdiFaults::EUsbTransferDescriptorBadHandle));

	TUint8* chunkBase = iChunk.Base() + iBaseOffset;

	TInt resultsOffset = UsbZeroCopyIsocChunkHeader::ResultsOffset(chunkBase, aHandle);

	TInt* resultsPtr = reinterpret_cast<TInt*>(chunkBase + resultsOffset);

	TInt& maxNumPackets = UsbZeroCopyIsocChunkHeader::MaxNumPackets(chunkBase, aHandle);

	return TPacketResults(resultsPtr, maxNumPackets);

	}

TInt RUsbZeroCopyTransferStrategy::MaxPacketSize(TInt aHandle)

	{

	__ASSERT_DEBUG(aHandle >= 0, UsbdiUtils::Fault(UsbdiFaults::EUsbTransferDescriptorBadHandle));

	TUint8* chunkBase = iChunk.Base() + iBaseOffset;

	TInt maxPacketSize = UsbZeroCopyIsocChunkHeader::MaxPacketSize(chunkBase, aHandle);

	return maxPacketSize;

	}

TPtr8 RUsbZeroCopyTransferStrategy::WritablePackets(TInt aHandle, TInt aWriteHandle, TInt aNumPacketsRequested, TInt& aMaxNumPacketsAbleToWrite)

	{

	__ASSERT_DEBUG(aHandle >= 0, UsbdiUtils::Fault(UsbdiFaults::EUsbTransferDescriptorBadHandle));

	__ASSERT_DEBUG(aWriteHandle >= 0, UsbdiUtils::Fault(UsbdiFaults::EUsbTransferDescriptorBadWriteHandle));

	TUint8* chunkBase = iChunk.Base() + iBaseOffset;

	const TUint32 pageAddrBits = iPageSize-1;

	const TUint32 pageTableMask = ~pageAddrBits;

	if (aHandle == aWriteHandle)

		{

		// The initial write handle will be the same as the standard handle so we need to find the actual 

		// element to work correctly.

		aWriteHandle = UsbZeroCopyIsocChunkHeader::FirstElementOffset(chunkBase, aHandle);

		}

	// Now we have two cases - the number of packets requested is contained in one page, or it crosses the page.

	// 1) If we cross the page then we get the buffer for upto the end of the page, and inform the user of the number

	// of packets they are able to write into it (normally this will be quite high as we can consider 0 length

	// packets.)

	// 2) If we are on one page then we provide a buffer to the end of the page and return the number of packets

	// the requested as the max they can write.  However we also now mark it so that an attempt to get a subsequent

	// writable buffer will return a 0 max length TPtr8 and 0 max number of packets to write.  If they want write

	// more they need to reset the descriptor and start again.

	if (UsbZeroCopyIsocChunkElement::NumPackets(chunkBase, aWriteHandle) == UsbZeroCopyIsocChunkElement::KInvalidElement)

		{

		// Here we are testing the second case, if we previously marked an element as invalid then we must not

		// return a valid buffer.

		aMaxNumPacketsAbleToWrite = 0;

		return TPtr8(NULL, 0);

		}

	TInt dataOffset = UsbZeroCopyIsocChunkElement::DataOffset(chunkBase, aWriteHandle);

	TUint8* dataPtr = chunkBase + dataOffset;

	TInt totalMaxSize = aNumPacketsRequested * UsbZeroCopyIsocChunkHeader::MaxPacketSize(chunkBase, aHandle);

	// The USB stack requires isoc transfer to be limited to a page (not allowed to cross the boundary).

	TUint32 dataAddr = reinterpret_cast<TUint32>(dataPtr);

	TBool samePage = (pageTableMask & dataAddr) == (pageTableMask & (dataAddr + totalMaxSize));

	TInt allowableSize = samePage ? totalMaxSize : iPageSize - (pageAddrBits & dataAddr);

	TInt numPacketsRemaining = UsbZeroCopyIsocChunkHeader::MaxNumPackets(chunkBase, aHandle) - UsedPackets(aHandle);

	if (aNumPacketsRequested < numPacketsRemaining)

		{

		// This is the 2nd case as documented in the comment.  So we mark the next packet as invalid.

		aMaxNumPacketsAbleToWrite = aNumPacketsRequested;

		TInt nextElement = UsbZeroCopyIsocChunkElement::NextElementOffset(chunkBase, aWriteHandle);

		if (nextElement != UsbZeroCopyIsocChunkElement::KEndOfList)

			{

			UsbZeroCopyIsocChunkElement::NumPackets(chunkBase, nextElement) = UsbZeroCopyIsocChunkElement::KInvalidElement; // Mark as invalid.

			}

		// else we are at the end of the list anyway

		}

	else

		{

		aMaxNumPacketsAbleToWrite = numPacketsRemaining;

		}

	return TPtr8(dataPtr, allowableSize);

	}