1 // Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32\drivers\usbcsc\d_usbcsc.cpp

    15 // LDD for USB Device driver stack, using shared chunks:

    16 // The channel object.

    17 // 

    18 //

    19 

    20 /**

    21  @file d_usbcsc.cpp

    22  @internalTechnology

    23 */

    24 

    25 #include <drivers/usbcsc.h>

    26 #include "platform.h"

    27 

    28 /*****************************************************************************\

    29 *   DUsbcScLogDevice                                                          *

    30 *                                                                             *

    31 *   Inherits from DLogicalDevice, the USB Shared Chunk LDD factory class      *

    32 *                                                                             *

    33 \*****************************************************************************/

    34 

    35 _LIT(KUsbScLddName, "Usbcsc");

    36 

    37 static const TInt KUsbRequestCallbackPriority = 2;

    38 

    39 /** Real entry point from the Kernel: return a new driver.

    40  */

    41 DECLARE_STANDARD_LDD()

    42 	{

    43 	return new DUsbcScLogDevice;

    44 	}

    45 

    46 /** Create a channel on the device.

    47 

    48 	@internalComponent

    49 */

    50 TInt DUsbcScLogDevice::Create(DLogicalChannelBase*& aChannel)

    51 	{

    52 	aChannel = new DLddUsbcScChannel;

    53 	return aChannel ? KErrNone : KErrNoMemory;

    54 	}

    55 

    56 

    57 DUsbcScLogDevice::DUsbcScLogDevice()

    58       {

    59 	  iParseMask = KDeviceAllowUnit;

    60 	  iUnitsMask = 0xffffffff;								// Leave units decision to the Controller

    61       iVersion = TVersion(KUsbcScMajorVersion, KUsbcScMinorVersion, KUsbcScBuildVersion);

    62       }

    63 

    64 

    65 TInt DUsbcScLogDevice::Install()

    66 	{

    67 	// Only proceed if we have the Controller underneath us

    68 	if (!DUsbClientController::UsbcControllerPointer())

    69 		{

    70 		__KTRACE_OPT(KPANIC, Kern::Printf("LDD Install: USB Controller Not Present"));

    71 		return KErrGeneral;

    72 		}

    73 	return SetName(&KUsbScLddName);

    74 	}

    75 

    76 

    77 //

    78 // Return the USB controller capabilities.

    79 //

    80 void DUsbcScLogDevice::GetCaps(TDes8& aDes) const

    81 	{

    82 	TPckgBuf<TCapsDevUsbc> b;

    83 	b().version = iVersion;

    84 	Kern::InfoCopy(aDes, b);

    85 	}

    86 

    87 // End DUsbcScLogDevice

    88 

    89 /*****************************************************************************\

    90 *   TUsbcScChunkInfo                                                          *

    91 *                                                                             *

    92 *   Where Chunk information is stored for the channel, and preseved for the   *

    93 *   life of the chunk.                                                        *

    94 *                                                                             *

    95 \*****************************************************************************/

    96 

    97 void DfcChunkCleanup(TAny*);

    98 

    99 TUsbcScChunkInfo::TUsbcScChunkInfo(DLogicalDevice* aLdd)

   100 	: 	iChunk(NULL),

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

   102 		iChunkMem(NULL),

   103 		iLdd(aLdd)

   104 	{

   105 	iPageNtz = (TInt8)__e32_find_ls1_32(Kern::RoundToPageSize(1));

   106 	}

   107 

   108 TInt TUsbcScChunkInfo::CreateChunk(TInt aTotalSize)

   109 	{

   110 	// First, reserve an TUint of memory for each of pages needed to hold aTotalSize of memory.

   111 	// This will form the chunk map, so that we can look up the memory geometry.

   112 	iAllocatedSize = (aTotalSize>>iPageNtz)*sizeof(TUint);

   113 	iPhysicalMap = (TUint*) Kern::AllocZ(iAllocatedSize);

   114 	TInt r;

   115 	if (iPhysicalMap==NULL)

   116 		r = KErrNoMemory;

   117 	else

   118 		{

   119 		TChunkCreateInfo chunkInfo;

   120 		chunkInfo.iType = TChunkCreateInfo::ESharedKernelMultiple;

   121 		chunkInfo.iMaxSize = aTotalSize;

   122 		chunkInfo.iMapAttr = EMapAttrCachedMax;

   123 		chunkInfo.iOwnsMemory = EFalse;

   124 		chunkInfo.iDestroyedDfc = &iCleanup;

   125 

   126 		TLinAddr chunkMem;

   127 		r = Kern::ChunkCreate(chunkInfo, iChunk, chunkMem, iChunkMapAttr);

   128 		iChunkMem = (TInt8*) chunkMem;

   129 		if (r==KErrNone)

   130 			iLdd->Open();

   131 		}

   132 

   133 	return r;

   134 }

   135 

   136 

   137 // This method requests closing the chunk.

   138 // Note that nothing may happen immediately, as something else may have the chunk open.

   139 void TUsbcScChunkInfo::Close()

   140 {

   141 	Kern::ChunkClose(iChunk);	

   142 }

   143 

   144 

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

   146 	{

   147 	TUint pageMask = (~0)<<iPageNtz;

   148 	TUint rleMask = ~pageMask;

   149 	TUint pageSize = rleMask+1;

   150 	TInt r;

   151 	TLinAddr physAddr;

   152 

   153 	__KTRACE_OPT(KUSB, Kern::Printf("::chunkalloc  AllocPhysicalRam aSize %d", aSize));

   154 

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

   156 	__KTRACE_OPT(KUSB, if (r!=KErrNone) Kern::Printf("::chunkalloc AllocPhysicalRam r=%d  (Error!)", r));

   157 	if (r==KErrNone)

   158 		{	

   159 		__KTRACE_OPT(KUSB, Kern::Printf("::chunkalloc ChunkCommitPhysical iChunk 0x%x size(%d), aOffset 0x%x, aSize 0x%x phsAddr 0x%x",

   160 																	 				iChunk, sizeof(DChunk), aOffset, aSize,physAddr ));

   161 

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

   163 		__KTRACE_OPT(KUSB, if (r!=KErrNone) Kern::Printf("::chunkalloc ChunkCommitPhysical r=%d  (Error!)", r));

   164 

   165 		if (r!=KErrNone)

   166 				Epoc::FreePhysicalRam(physAddr, aSize);

   167 		else 

   168 			{ // record physical address and length in physical map

   169 			TInt rle;

   170 			TInt i=0;

   171 			for (rle=(aSize>>iPageNtz); rle>0; rle--, i++,physAddr+=pageSize) 

   172 				{

   173 				__KTRACE_OPT(KUSB, Kern::Printf("::phys offset 0x%x = 0x%x",

   174 												(aOffset>>iPageNtz)+i,  (physAddr & pageMask) | ((rle>(TInt)rleMask)?(TInt)rleMask:rle)));

   175 				iPhysicalMap[(aOffset>>iPageNtz)+i] = (physAddr & pageMask) | ((rle>(TInt)rleMask)?(TInt)rleMask:rle);

   176 				}

   177 			}

   178 		}

   179 	else if (r==KErrNoMemory)

   180 		r = -KErrNoMemory;  // Semi-expected error.

   181 	return r;

   182 	}

   183 

   184 /**

   185 This method retrieves the physical address of a given offset into the Chunk, and returns

   186 the length of contiguous physical memory from this point.

   187 

   188 @param aOffset		the offset from the start of the chunk, to be queried.

   189 @param aPhysical	a pointer to a TPhysAddr, to be filled with the physical

   190 					address of the memory at the given offset.

   191 

   192 @returns the length of contiguous physical memory from the given offset.

   193 */

   194 

   195 TInt TUsbcScChunkInfo::GetPhysical(TInt aOffset, TPhysAddr* aPhysical)

   196 	{

   197 	// Use masks, to retrieve the two components from the physical map, we created of the memory.

   198 	TUint pageMask = (~0)<<iPageNtz;

   199 	TUint val =  iPhysicalMap[aOffset>>iPageNtz];

   200 	*aPhysical=(val & pageMask)+(aOffset & ~pageMask);

   201 	return ((val & ~pageMask)<<iPageNtz) -  (aOffset & ~pageMask);

   202 	}

   203 

   204 

   205 // DFC calls this fuction, which invokes the cleanup method.

   206 

   207 void DfcChunkCleanup(TAny* aChunkInfo)

   208 	{

   209 	((TUsbcScChunkInfo*) aChunkInfo)->ChunkCleanup();

   210 	}

   211 

   212 

   213 void TUsbcScChunkInfo::ChunkCleanup()

   214 {

   215 	__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScChunkInfo::ChunkCleanup()"));

   216 	TUint physAddr;

   217 	TInt length;

   218 	TInt offset = 0;

   219 	

   220 	// The part of the field used for the physical page address.

   221 	TUint pageMask = (~0)<<iPageNtz;

   222 

   223 	// The part of the field used for the run length encoding, of the contiguous pages.

   224 	TUint rleMask = ~pageMask;

   225 	TInt records=(iAllocatedSize>>2);

   226 

   227 	while (offset < records) 

   228 		{

   229 		physAddr = 	iPhysicalMap[offset] & pageMask;

   230 		length = iPhysicalMap[offset] & rleMask;

   231 

   232 		if (physAddr>0)	

   233 			Epoc::FreePhysicalRam(physAddr, length);

   234 

   235 		offset += (length>0)?length:1;

   236 		}

   237 	Kern::Free(iPhysicalMap);

   238 

   239 	DLogicalDevice* ldd = iLdd;

   240 	delete this;

   241 	ldd->Close(NULL);

   242 }

   243 

   244 TInt TUsbcScChunkInfo::New(TUsbcScChunkInfo*& aChunk, TInt aSize, DLogicalDevice* aLdd)

   245 {

   246 	__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScChunkInfo::New totalSize %d", aSize));

   247 

   248 	aChunk = new TUsbcScChunkInfo(aLdd);

   249 	if (aChunk==NULL)

   250 		{

   251 		return KErrNoMemory;

   252 		}

   253 					

   254 	TInt r = aChunk->CreateChunk(aSize);

   255 	if (r!=KErrNone)

   256 		{

   257 		delete aChunk;

   258 		aChunk=NULL;

   259 		return r;

   260 		}

   261 

   262 	__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScChunkInfo::New Created at 0x%x",  aChunk->iChunkMem  ));

   263 	return KErrNone;

   264 }

   265 

   266 // End TUsbcScChunkInfo

   267 

   268 /*****************************************************************************\

   269 *    TUsbcScBuffer                                                            *

   270 *                                                                             *

   271 *    Represents a buffer, within a chunk.  Each buffers can be used by        *

   272 *    differt endpoint on differnt alt settings                                *

   273 *                                                                             *

   274 \*****************************************************************************/

   275 

   276 

   277 TInt TUsbcScBuffer::Construct(TInt aDirection, DLddUsbcScChannel* aLdd, TInt aBufferOffset, TInt aBufferEndOffset, TInt aMinReadSize, TInt aMaxPacketSize, TInt aMaxReadSize)

   278 	{

   279 	TInt r;

   280 #ifdef _DEBUG

   281 	iSequence = aBufferOffset; // Initialized at this, so that each buffer starts with a diffrent sequence number

   282 #endif

   283 	iMinReadSize = aMinReadSize;

   284 	TInt size = (aBufferEndOffset - aBufferOffset);

   285 	TInt pageSize = Kern::RoundToPageSize(1);

   286 	if (aMaxReadSize > 0)

   287 		iMaxReadSize = aMaxReadSize;

   288 	else

   289 		iMaxReadSize = pageSize + ((size/3) & ~(pageSize -1));

   290 	iLdd = aLdd;

   291 	iDirection = aDirection;

   292 	iMode=0;

   293 	iChunkInfo = aLdd->iChunkInfo;

   294 	iChunkAddr = (TLinAddr) (aLdd->iChunkInfo->iChunkMem);  //aChunkAddr;

   295 

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

   297 

   298 

   299 	TUint maxAlignment; // Note:  This is a mask for max Alignment, 

   300 

   301 	if (aMaxPacketSize)

   302 		{ // EP0 packets are not DMAed, and so dont need ialignment.

   303 		iAlignMask = ~3;

   304 		maxAlignment = 3;

   305 		}

   306 	else

   307 		 maxAlignment = 1023; // We don't know what the alignment requirement will be until enumeration, so assume worse case.

   308 

   309 	iFirstPacket = aBufferOffset + sizeof(SUsbcScBufferHeader) + headerSize;

   310 	iFirstPacket = (iFirstPacket + maxAlignment) & ~maxAlignment;

   311 	

   312 	iBufferStart = (SUsbcScBufferHeader *) (iChunkAddr+aBufferOffset);

   313 	iBufferEnd = aBufferEndOffset;

   314 

   315 	if ((iDirection&1)==KUsbcScOut)

   316 		iHead = iFirstPacket-headerSize;//aBufferOffset + sizeof(SUsbcScBufferHeader);

   317 	else

   318 		iSent = 0;

   319 

   320 	iStalled=0;

   321 	iMaxPacketSize=0;

   322 	

   323 	r =  iStatusList.Construct((aDirection==KUsbcScIn)?KUsbcScInRequests:KUsbcScOutRequests, iLdd->iClient);

   324 	if (!r)

   325 		{

   326 		iMaxPacketSize = aMaxPacketSize; // Indicates configured if ep0, otherwise not.

   327 		}

   328 	return r;

   329 	}

   330 

   331 

   332 void TUsbcScBuffer::CreateChunkBufferHeader()

   333 {

   334 	if ((iDirection&1)==KUsbcScOut)

   335 		{

   336 		iBufferStart->iHead= iHead;

   337 		iBufferStart->iTail= iHead; // Initially no data!

   338 		iBufferStart->iBilTail=iHead;

   339 		__KTRACE_OPT(KUSB, Kern::Printf("Realize:  iHead 0x%x  bufferHeader 0x%x", iHead,iBufferStart ));

   340 

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

   342 		}

   343 }

   344 

   345 /*

   346 TUsbcScBuffer::StartEndpoint

   347 

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

   349 

   350 */

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

   352 	{

   353 	__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartEndpoint (0x%x) : ep %d(%d)",this,aRequestInfo->iEndpointNum, aRequestInfo->iRealEpNum));

   354 	

   355 	iCallback=aRequestInfo;

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

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

   358 	iMode = aFlags;

   359     __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartEndpoint : max Packets %d, mask 0x%x flags 0x%x", iMaxPacketSize, iAlignMask, iMode));

   360 	if ((iDirection&1)==KUsbcScOut)

   361 		{

   362 		__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UsbcScOut\n"));

   363 		// Add dummy packet (doesnt have to be aligned, which avoids what if it changes issue)

   364 		// And Start next read.

   365 		iNeedsPacket=KEpIsStarting;

   366 		}

   367 	}

   368 

   369 

   370 

   371 void TUsbcScBuffer::Destroy()

   372 {

   373 	__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::Destroy()"));

   374 	Cancel(KErrCancel);

   375 	if (iLdd->iController && ((iDirection&1)==KUsbcScOut))  

   376 		{  // Me must cancel reads to LDD to, an there will be no list for the callbacks to look into.

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

   378 		}

   379 	iStatusList.Destroy();

   380 }

   381 

   382 

   383 

   384 TInt TUsbcScBuffer::StartDataRead()

   385 {

   386 	if (!iMaxPacketSize)

   387 	{

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

   389 		return KErrNone;

   390 	}

   391 	if (iStatusList.iState!=ENotRunning) 

   392 		{

   393 		__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartDataRead() - Already Stated! (%d)",iStatusList.iState));

   394 		return KErrNone;

   395 		}

   396 

   397 	TInt maxLength;

   398 	TInt freeSpace;

   399 	TPhysAddr physAddr;

   400 

   401 	// get next request

   402 	TUsbcScStatusElement* nextJob = iStatusList.Next();

   403 	if (nextJob == NULL)

   404 		{

   405 		__KTRACE_OPT(KUSB, Kern::Printf("No more jobs"));

   406 		if (iMode && KUsbScCoupledRead)

   407 			return KErrEof;

   408 		iStatusList.iState=EReadingAhead;

   409 		}

   410 	else

   411 		iStatusList.iState=EInProgress;

   412 

   413 	TInt tail = iBufferStart->iTail;

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

   415 	maxLength = iChunkInfo->GetPhysical(iHead + headerSize, &physAddr); //returns all the bytes available after iHead + headerSize)

   416 

   417 	__ASSERT_DEBUG(maxLength>0,Kern::Fault("TUsbcScBuffer::StartDataRead(", __LINE__)); 

   418 

   419 

   420 	if (tail>iHead)  //  # # # H _ _ _ T # # # #

   421 		{

   422 		__KTRACE_OPT(KUSB,Kern::Printf("TUsbcScBuffer::StartDataRead() - tail 0x%x>head 0x%x, maxlength 0x%x", tail, iHead, maxLength));

   423 

   424 		freeSpace = (tail & iAlignMask) - (iHead +headerSize + (~iAlignMask+1) );  // Cant read right up to last buffer, or head/tail will cross.

   425 

   426 		if (freeSpace<iMinReadSize)

   427 			{

   428 			iStatusList.iState=ENotRunning;

   429 			__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartDataRead() - Stall!!"));

   430 			return KErrOverflow; 				// Read STALL !! !! !!

   431 			}

   432 

   433 		if (freeSpace<maxLength)

   434 			maxLength = freeSpace;

   435 		}

   436 	if (maxLength> iMaxReadSize) 

   437 		maxLength =  iMaxReadSize;

   438 	// else  tail<iHead (or empty)      _ _ _ T # # # H _ _ _ _

   439 	// We would not have set iHead here if too small. So must be ok.

   440 		

   441 	__ASSERT_DEBUG(maxLength>=iMinReadSize,Kern::Fault("TUsbcScBuffer::StartDataRead(", __LINE__)); 

   442 

   443 	TUint8* data = ((TUsbcScTransferHeader *) (iHead + iChunkAddr))->iData.b;

   444 	// set up callback stucture

   445 

   446 	iCallback->SetRxBufferInfo(data, physAddr, iIndexArray, iSizeArray,maxLength);

   447 	TInt r;

   448 	// Go!!

   449 	r = iLdd->iController->SetupReadBuffer(*iCallback);

   450 	if (r!=KErrNone)

   451 		{

   452 		__KTRACE_OPT(KUSB,Kern::Printf("SetupReadBuffer Error: %d, RT %d",r, iStatusList.iState));

   453 		iStatusList.Complete(r);

   454 		}

   455 	// After this, TUsbcScEndpoint::RequestCallback is called in a DFC.

   456 	// This in turn calls either TUsbcScBuffer::CompleteRead.

   457 	return KErrNone;

   458 }

   459 

   460 

   461 void TUsbcScBuffer::CompleteRead(TBool aStartNextRead)

   462 {

   463 	__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::CompleteRead buff=%x",this));

   464 

   465     // The first packet always contains the total #of bytes

   466 	const TInt byteCount = iCallback->iPacketSize[0];

   467 	const TInt packetCount = iCallback->iRxPackets;

   468  	iCallback->iRxPackets=0;

   469 	TUint flags = 0;

   470 

   471 	if (iCallback->iPacketSize[packetCount - 1] < (TUint) iMaxPacketSize)

   472 		flags = KUsbcScShortPacket;

   473 

   474 	UpdateBufferList(byteCount, flags, aStartNextRead);

   475 }

   476 

   477 

   478 // This method "submits" the current transfer, and starts off the next read.

   479 

   480 void TUsbcScBuffer::UpdateBufferList(TInt aByteCount,TUint aFlags, TBool aStartNextRead)

   481 	{

   482 

   483 	__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UpdateBUfferLIst aByteCount %d, flags 0x%x iHead 0x%x", aByteCount, aFlags, iHead));

   484 

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

   486 	TLinAddr dummy;

   487 	__KTRACE_OPT(KUSB, Kern::Printf("iHead 0x%x headerSize 0x%x",iHead, headerSize));

   488 

   489 	// Find iNext

   490 

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

   492 	TInt maxLength; 

   493 

   494 	// This may take a few loops before we settle on a value.

   495 	do 

   496 		{

   497 		// round up.

   498 		next = (next + headerSize + ~iAlignMask) & iAlignMask;

   499 		maxLength = iChunkInfo->GetPhysical(next, &dummy);

   500 

   501 		__KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UpdateBUfferLIst  next %x  buffer end %x min-read: %x  maxRun %x", next, iBufferEnd, iMinReadSize, maxLength));

   502 		// At the end of the buffer - wrap it if needbe.

   503 		if ((TUint)(next + iMinReadSize) > iBufferEnd)

   504 			{

   505 			next = iFirstPacket;

   506 			continue;

   507 			}

   508 		// Not enough space, move onto next block.

   509 		if (maxLength<iMinReadSize) 

   510 			{

   511 			next+=maxLength;

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

   513 			continue;

   514 			}

   515 		}

   516 	while (EFalse);

   517 

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

   519 	

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

   521 

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

   523 	

   524 // Create Header

   525 #ifdef _DEBUG

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

   527 	header->iSequence=iSequence;

   528 	iSequence++;

   529 #endif

   530 	header->iBytes=aByteCount;

   531 	header->iNext=next;

   532 	header->iAltSettingSeq=iLdd->iAsSeq;

   533 	header->iAltSetting=iLdd->iAlternateSetting;

   534 	header->iFlags=aFlags;

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

   536 

   537 	iStatusList.iState=ENotRunning;

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

   539 		{

   540 			iStalled=next;

   541 		}

   542 	else

   543 		{

   544 

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

   546 		TInt oldHead=iHead;

   547 		iHead = next;

   548 

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

   550 			{ // Oh crumbs, set state as slalled.

   551 			if (oldHead != iBufferStart->iBilTail) 

   552 				// If user has not read everything in the buffer

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

   554 				{

   555 				iStalled=next;

   556 				iHead=oldHead;

   557 				}

   558 			else // otherwise if everything is read

   559 				// no choice but to return what we have

   560 				{

   561 				iBufferStart->iHead = iHead;

   562 				}

   563 			}

   564 		else

   565 			{

   566 			iBufferStart->iHead = next;

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

   568 			}

   569 		// Complete userside

   570 		iStatusList.Complete();

   571 		}  

   572 	}

   573 

   574 void TUsbcScBuffer::PopStall()

   575 	{

   576 	if (iStalled==iBufferStart->iTail)

   577 		return;  // Still stalled.

   578 

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

   580 	{

   581 		// pop off packet	

   582 		iHead = iStalled;

   583  	}

   584 	iStalled=0;

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

   586 	// Add alt setting change packet.

   587 

   588 

   589 	if (StartDataRead() == KErrOverflow)

   590 	{

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

   592 	}

   593 

   594 	iBufferStart->iHead = iHead;

   595 	}

   596 

   597 

   598 

   599 void TUsbcScBuffer::StartDataWrite()

   600 	{

   601 	

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

   603 	TUsbcScStatusElement* nextJob = iStatusList.Next();

   604 	TBool zlpReqd;

   605 	TInt length;

   606 	TUint start;

   607 	TUint8* startAddr;

   608 	TInt maxLength;

   609 	TPhysAddr physAddr;

   610 	TInt r;

   611 	if (!iMaxPacketSize)

   612 	{

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

   614 		return;

   615 	}

   616 

   617 	if (nextJob == NULL)

   618 		{

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

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

   621 			{

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

   623 			// Start other read again.

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

   625 			}

   626 		}

   627 	else

   628 		{

   629 		if (iStatusList.iState==ENotRunning)

   630 			iSent=0;

   631 		iStatusList.iState=EInProgress;

   632 

   633 		start = nextJob->iStart;

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

   635 

   636 		length = nextJob->iLength;

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

   638 		// get max read length

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

   640 

   641 		if (maxLength < length)

   642 			{

   643 				// modify request.

   644 				nextJob->iStart += maxLength;

   645 				nextJob->iLength -= maxLength;

   646 				// start this request.

   647 				iStatusList.iState=EFramgementInProgress;

   648 				zlpReqd=EFalse;

   649 				length =  maxLength;

   650 			}

   651 

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

   653 			{

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

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

   656 			}

   657 		

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

   659 		iCallback->iZlpReqd = zlpReqd;

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

   661 		if (r!=KErrNone)

   662 			{

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

   664 			iStatusList.Complete(r);

   665 			}

   666 		}

   667 

   668 	}

   669 

   670 void TUsbcScBuffer::CompleteWrite()

   671 	{

   672 	TInt error = iCallback->iError;

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

   674 	iSent+= iCallback->iTxBytes;

   675 

   676 	// More to send?

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

   678 		{

   679 		// complete request with error (if one).

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

   681 		iStatusList.Complete(error);

   682 		}

   683 

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

   685 	StartDataWrite();

   686 	

   687 	}

   688 

   689 // Cancels the current request's callback.

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

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

   692 // that are not yet started.

   693 void TUsbcScBuffer::Cancel(TInt aErrorCode)

   694 	{

   695 	iStatusList.CancelQueued();

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

   697 		{

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

   699 		}

   700 

   701 	iStatusList.Complete(aErrorCode);

   702 	}

   703 

   704 void TUsbcScBuffer::Ep0CancelLddRead()

   705 	{

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

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

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

   709 	

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

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

   712 		{

   713 		// remove DFC (if infact sent)

   714 		iCallback->iDfc.Cancel();

   715 

   716 		// process the callback now, but dont start another

   717 		CompleteRead(EFalse);

   718 		}

   719 	}

   720 

   721 void TUsbcScBuffer::SendEp0StatusPacket(TInt aState)

   722 {

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

   724 

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

   726 	// another after we have added out packet.  

   727 	Ep0CancelLddRead();

   728 

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

   730 	*state = aState;

   731 	UpdateBufferList(4,KUsbcScStateChange);

   732 }

   733 

   734 // End TUsbcScBuffer

   735 

   736 /*****************************************************************************\

   737 *    TUsbcScStatusList                                                        *

   738 *                                                                             *

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

   740 *    requests, that should later be completed.                                *

   741 *                                                                             *

   742 \*****************************************************************************/

   743 

   744 /**

   745 Constructor for TUsbcScStatusList.

   746 

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

   748 				must be a power of two, for correct operation.

   749 

   750 @returns KErrNoMemory if memory allocation failure, otherwise KErrNone.

   751 */

   752 

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

   754 	{

   755 	iSize=aSize;

   756 	iHead = 0;

   757 	iLength = 0;

   758 	iClient = aClient;

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

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

   761 	};

   762 

   763 

   764 // StatusList must be inactive before destroying.

   765 void TUsbcScStatusList::Destroy()

   766 	{

   767 	if (iState!=ENotRunning)

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

   769 	if (iElements)

   770 		{

   771 		Kern::Free(iElements);	

   772 		iElements=NULL;

   773 		}

   774 	iClient=NULL;

   775 }

   776 

   777 void TUsbcScStatusList::Pop()

   778 	{

   779 	if (iLength>0)

   780 		{

   781 		iLength--;

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

   783 		}

   784 	}

   785 

   786 TUsbcScStatusElement* TUsbcScStatusList::Next()

   787 	{

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

   789 	}

   790 

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

   792 	{

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

   794 	if (iLength<iSize)

   795 		{

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

   797 		e.iStatus = aStatus;

   798 		e.iLength = aLength;

   799 		e.iStart = aStart;

   800 		e.iFlags = aFlags;

   801 		iLength++;

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

   803 

   804 		return KErrNone;

   805 		}

   806 	else

   807 		return KErrInUse;

   808 	}

   809 

   810 

   811 

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

   813 

   814 void TUsbcScStatusList::CancelQueued(TInt aError)

   815 {

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

   817 		return;  

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

   819 	TInt head = iHead;

   820 	iLength = 0;

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

   822 		{

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

   824 		iLength = 1;

   825 		}

   826 	// complete them all.

   827 	for (; elements2Complete>0; elements2Complete--)

   828   		{

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

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

   831   		}

   832 	

   833 }

   834 

   835 

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

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

   838 chained - usually because of an error.

   839 

   840 @Param aError - the code to complete with.

   841 

   842 returns KErrNotFound if there was no request to complete

   843 */

   844 

   845 

   846 TInt TUsbcScStatusList::Complete(TInt aError)

   847 	{

   848 	if (iState==ENotRunning)

   849 		{

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

   851 		}

   852  	else

   853 		{

   854 		iState=ENotRunning;

   855 		if (iLength==0)

   856 			return KErrNotFound;

   857 

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

   859 

   860 		iLength--;

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

   862 		}

   863 	return KErrNone;

   864 	}

   865 

   866 

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

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

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

   870 */

   871 

   872 void TUsbcScStatusList::Complete()

   873 	{

   874 	if (iLength==0)

   875 		return;

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

   877 

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

   879 

   880 	iLength--;

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

   882 	}

   883 

   884 // End TUsbcScStatusList

   885 

   886 /*****************************************************************************\

   887 *   TRealizeInfo                                                              *

   888 *                                                                             *

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

   890 *                                                                             *

   891 \*****************************************************************************/

   892 

   893 // Init

   894 //

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

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

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

   898 // the endpoints.  

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

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

   901 // before RealizeInteface has finished.

   902 

   903 void TRealizeInfo::Init(TUsbcScAlternateSettingList* aAlternateSettingList)

   904 {

   905 	iAlternateSettingList = aAlternateSettingList;

   906 	iMaxEndpoints=0;

   907 	iTotalSize   =0;

   908 	iTotalBuffers=0;

   909 	iAltSettings =0;

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

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

   912 

   913 	if (iAlternateSettingList)

   914 		{

   915 		TUsbcScAlternateSetting* alt = iAlternateSettingList->iHead;

   916 		while (alt != NULL) 

   917 			{

   918 			iAltSettings++;

   919 			if (alt->iNumberOfEndpoints>iMaxEndpoints)

   920 				iMaxEndpoints = alt->iNumberOfEndpoints;

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

   922 			alt = alt->iNext;

   923 			};

   924 		}

   925 	

   926 	// Alloc some temporary working space for temp endpoint metadata 

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

   928 	TInt inout;

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

   930 		{

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

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

   933 		}

   934 }

   935 

   936 // CopyAndSortEndpoints

   937 //

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

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

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

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

   942 // Realize_InitRealizeInfo. 

   943 //

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

   945 //

   946 

   947 TInt TRealizeInfo::CopyAndSortEndpoints()

   948 	{

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

   950 

   951 	TInt altSetting = 0;

   952 	TInt endpointOffs;

   953 	TInt endpoint;

   954 	TInt altEp;

   955 	TInt inout;

   956 	TBool placed;

   957 	TUsbcScAlternateSetting* alt;

   958 	TEndpointSortBufs* bufsd;

   959 

   960 	if (iAlternateSettingList)

   961 		{

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

   963 			{		

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

   965 

   966 			iBufs[KUsbcScIn].iEps =0;

   967 			iBufs[KUsbcScOut].iEps =0;

   968 

   969 			// For alt setting, iterate eps

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

   971 				{

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

   973 

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

   975 

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

   977 				

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

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

   980 				if (inout==KUsbcScUnknown)

   981 					{

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

   983 					return KErrArgument;

   984 					}

   985 

   986 				bufsd = &(iBufs[inout]);

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

   988 

   989 

   990 				// find and position ep, and insert.

   991 

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

   993 					{

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

   995 					endpointOffs = altSetting*iMaxEndpoints;

   996 					bufsd->iEp[endpointOffs] = nextEp;

   997 					}

   998 				else

   999 					{

  1000 					placed = EFalse;

  1001 					// Move down the list, until we find the right place.

  1002 					for (endpoint=bufsd->iEps-1; endpoint>-1; endpoint--)

  1003 						{

  1004 						endpointOffs = altSetting*iMaxEndpoints + endpoint;

  1005 						if (bufsd->iEp[endpointOffs]->EndpointInfo()->iBufferSize < nextEp->EndpointInfo()->iBufferSize)

  1006 							{

  1007 							__KTRACE_OPT(KUSB, Kern::Printf("Realize:       Shift Endpoint %d", endpoint));

  1008 		

  1009 							bufsd->iEp[endpointOffs+1] = bufsd->iEp[endpointOffs];

  1010 							}

  1011 						else

  1012 							{

  1013 							__KTRACE_OPT(KUSB, Kern::Printf("Realize:       Insert After Endpoint %d", endpoint));

  1014 

  1015 							bufsd->iEp[endpointOffs+1] = nextEp;

  1016 							placed = ETrue;

  1017 							break;

  1018 							}

  1019 						} // end for endpoint

  1020 						if (!placed) // if we didn't place it, it must be the biggest so far, so goes at the top.

  1021 							bufsd->iEp[0] = nextEp;

  1022 					} // endif

  1023 				bufsd->iEps++;			

  1024 				} // for altEp

  1025 				altSetting++;

  1026 			} // for alt

  1027 		}// if iAltsettingList

  1028 	return KErrNone;

  1029 	}

  1030 

  1031 // CalcBuffSizes

  1032 //

  1033 // This works out the sizes of all the buffers, and stores the result in aBufInfo

  1034 // based on the buffer information provided in the same structure.

  1035 // Realize_CopyAndSortEndpoints is used to fill the structure with the informaition

  1036 // required.

  1037 

  1038 void TRealizeInfo::CalcBuffSizes()

  1039 	{

  1040 	__KTRACE_OPT(KUSB, Kern::Printf("Realize: Calculate Buffers"));

  1041 

  1042 	TInt endpoint;

  1043 	TInt inout;

  1044 	TInt altSetting;

  1045 	TUsbcScEndpoint* nextEp;

  1046 	TInt bufferSize;

  1047 	TEndpointSortBufs* bufsd;

  1048 

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

  1050 		{

  1051 		__KTRACE_OPT(KUSB, Kern::Printf("Realize:   Direction: %d", inout));

  1052 

  1053 

  1054 		bufsd = &(iBufs[inout]);

  1055 		// for each row, ie, buffer, find largest buffer need.

  1056 		for (endpoint=0; endpoint<iMaxEndpoints; endpoint++)

  1057 			{

  1058 			__KTRACE_OPT(KUSB, Kern::Printf("Realize:     endpoint %d", endpoint));

  1059 			TInt bufMaxSize=0;

  1060 			for (altSetting=0; altSetting< iAltSettings; altSetting++)

  1061 				{

  1062 				__KTRACE_OPT(KUSB, Kern::Printf("Realize:       altSetting %d", altSetting));

  1063 				nextEp= bufsd->iEp[altSetting* iMaxEndpoints + endpoint];

  1064 				if (nextEp!=NULL)

  1065 					{

  1066 					bufferSize = nextEp->EndpointInfo()->iBufferSize;

  1067 					__KTRACE_OPT(KUSB, Kern::Printf("Realize:       comparing size %d", bufferSize));

  1068 					if (bufferSize> bufMaxSize)

  1069 						 bufMaxSize = bufferSize;

  1070 					}

  1071 				} // for altsetting

  1072 			__KTRACE_OPT(KUSB, Kern::Printf("Realize:     bufMaxSize %d", bufMaxSize));

  1073 			bufsd->iSizes[endpoint] = bufMaxSize;

  1074 			if (bufMaxSize>0) 

  1075 				{

  1076 				iTotalSize += bufsd->iSizes[endpoint];

  1077 				iTotalBuffers++;

  1078 				}

  1079 			} // for endpoint

  1080 		} // for in/out	

  1081 }

  1082 

  1083 // Free

  1084 //

  1085 // Cleans up after Init()

  1086 

  1087 void TRealizeInfo::Free()

  1088 	{

  1089 	TInt inout;

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

  1091 		{

  1092 		Kern::Free(iBufs[inout].iEp);

  1093 		Kern::Free(iBufs[inout].iSizes);

  1094 		}

  1095 	}

  1096 

  1097 // End TRealizeInfo

  1098 

  1099 

  1100 // LayoutChunkHeader

  1101 //

  1102 // Sets up some geometry for the chunk;

  1103 

  1104 void TRealizeInfo::LayoutChunkHeader(TUsbcScChunkInfo* aChunkInfo)

  1105 { 

  1106 	// First set up the indexes to the header structures.

  1107 	TUsbcScChunkHdrOffs* chkHdr = (TUsbcScChunkHdrOffs*) aChunkInfo->iChunkMem;

  1108 

  1109 	chkHdr->iBuffers = sizeof(TUsbcScChunkHdrOffs); // First struct just after this one.

  1110 	iChunkStuct = (TUsbcScChunkBuffersHeader*) ( (TInt) aChunkInfo->iChunkMem + chkHdr->iBuffers);

  1111 

  1112 	// Store number of buffers in chunk

  1113 	iChunkStuct->iRecordSize = sizeof(TUsbcScBufferRecord);

  1114 	iChunkStuct->iNumOfBufs=iTotalBuffers;

  1115 

  1116 	iAltSettingsTbl = (TUsbcScChunkAltSettingHeader*) &(iChunkStuct->iBufferOffset[(iTotalBuffers+2)*sizeof(TUsbcScBufferRecord)]); // 2 extra for EP0 in and out.

  1117 

  1118 	chkHdr->iAltSettings = (TUint) iAltSettingsTbl - (TUint) aChunkInfo->iChunkMem;

  1119 

  1120 	iAltSettingsTbl->iEpRecordSize = sizeof(TUint);

  1121 	iAltSettingsTbl->iNumOfAltSettings = iAltSettings;

  1122 

  1123 

  1124 	TInt tableOffset  = (TUint) iAltSettingsTbl->iAltTableOffset - (TUint) aChunkInfo->iChunkMem + iAltSettings*sizeof(TInt);

  1125 	__KTRACE_OPT(KUSB, Kern::Printf("Realize: table offset: 0x%x, altTble %x iChnkMem %x altSettings %x",tableOffset, iAltSettingsTbl, aChunkInfo->iChunkMem, iAltSettings ));

  1126 

  1127 	__KTRACE_OPT(KUSB, Kern::Printf("Realize: populate chunk - create alt settings table"));

  1128 

  1129 	// Create alt settings table.  Set each element of altsettings table, to each induivatual alt setting table.

  1130 	// then fill in the number of endpoints for that alt setting, in the table.

  1131 

  1132 	TInt* noEpForAlt;

  1133 	TInt altSetting;

  1134 	TUsbcScAlternateSetting* alt;