2 // All rights reserved.

     2 // All rights reserved.

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

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

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

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

     5 // which accompanies this distribution, and is available

     5 // which accompanies this distribution, and is available

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

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

    19 

    19 

    20 /**

    20 /**

    21  @file d_usbcsc.cpp

    21  @file d_usbcsc.cpp

    22  @internalTechnology

    22  @internalTechnology

    23 */

    23 */

    24 #include <drivers/usbcsc.h>

    25 #include <drivers/usbcsc.h>

    25 #include "platform.h"

    26 #include "platform.h"

    31 

    27 

    32 /*****************************************************************************\

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

    33 *   DUsbcScLogDevice                                                          *

    29 *   DUsbcScLogDevice                                                          *

    34 *                                                                             *

    30 *                                                                             *

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

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

    69 TInt DUsbcScLogDevice::Install()

    65 TInt DUsbcScLogDevice::Install()

    70 	{

    66 	{

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

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

    72 	if (!DUsbClientController::UsbcControllerPointer())

    68 	if (!DUsbClientController::UsbcControllerPointer())

    73 		{

    69 		{

    76 		return KErrGeneral;

    71 		return KErrGeneral;

    77 		}

    72 		}

    78 	return SetName(&KUsbScLddName);

    73 	return SetName(&KUsbScLddName);

    79 	}

    74 	}

    80 

    75 

   101 

    96 

   102 void DfcChunkCleanup(TAny*);

    97 void DfcChunkCleanup(TAny*);

   103 

    98 

   104 TUsbcScChunkInfo::TUsbcScChunkInfo(DLogicalDevice* aLdd)

    99 TUsbcScChunkInfo::TUsbcScChunkInfo(DLogicalDevice* aLdd)

   105 	: 	iChunk(NULL),

   100 	: 	iChunk(NULL),

   106 		iChunkMem(NULL),

   102 		iChunkMem(NULL),

   107 		iLdd(aLdd)

   103 		iLdd(aLdd)

   108 	{

   104 	{

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

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

   110 	}

   106 	}

   123 		TChunkCreateInfo chunkInfo;

   119 		TChunkCreateInfo chunkInfo;

   124 		chunkInfo.iType = TChunkCreateInfo::ESharedKernelMultiple;

   120 		chunkInfo.iType = TChunkCreateInfo::ESharedKernelMultiple;

   125 		chunkInfo.iMaxSize = aTotalSize;

   121 		chunkInfo.iMaxSize = aTotalSize;

   126 		chunkInfo.iMapAttr = EMapAttrCachedMax;

   122 		chunkInfo.iMapAttr = EMapAttrCachedMax;

   127 		chunkInfo.iOwnsMemory = EFalse;

   123 		chunkInfo.iOwnsMemory = EFalse;

   129 

   125 

   130 		TLinAddr chunkMem;

   126 		TLinAddr chunkMem;

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

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

   132 		iChunkMem = (TInt8*) chunkMem;

   128 		iChunkMem = (TInt8*) chunkMem;

   133 		if (r==KErrNone)

   129 		if (r==KErrNone)

   140 

   136 

   141 // This method requests closing the chunk.

   137 // This method requests closing the chunk.

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

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

   143 void TUsbcScChunkInfo::Close()

   139 void TUsbcScChunkInfo::Close()

   144 {

   140 {

   152 }

   142 }

   153 

   143 

   154 

   144 

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

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

   156 	{

   146 	{

   158 	TUint rleMask = ~pageMask;

   148 	TUint rleMask = ~pageMask;

   159 	TUint pageSize = rleMask+1;

   149 	TUint pageSize = rleMask+1;

   160 	TInt r;

   150 	TInt r;

   161 	TLinAddr physAddr;

   151 	TLinAddr physAddr;

   162 

   152 

   164 

   154 

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

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

   168 	if (r==KErrNone)

   157 	if (r==KErrNone)

   169 		{	

   158 		{	

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

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

   175 

   164 

   176 		if (r!=KErrNone)

   165 		if (r!=KErrNone)

   177 				Epoc::FreePhysicalRam(physAddr, aSize);

   166 				Epoc::FreePhysicalRam(physAddr, aSize);

   178 		else 

   167 		else 

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

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

   180 			TInt rle;

   169 			TInt rle;

   181 			TInt i=0;

   170 			TInt i=0;

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

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

   183 				{

   172 				{

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

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

   187 				}

   176 				}

   188 			}

   177 			}

   189 		}

   178 		}

   190 	else if (r==KErrNoMemory)

   179 	else if (r==KErrNoMemory)

   221 	}

   210 	}

   222 

   211 

   223 

   212 

   224 void TUsbcScChunkInfo::ChunkCleanup()

   213 void TUsbcScChunkInfo::ChunkCleanup()

   225 {

   214 {

   228 	TUint physAddr;

   216 	TUint physAddr;

   229 	TInt length;

   217 	TInt length;

   230 	TInt offset = 0;

   218 	TInt offset = 0;

   231 	

   219 	

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

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

   253 	ldd->Close(NULL);

   241 	ldd->Close(NULL);

   254 }

   242 }

   255 

   243 

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

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

   257 {

   245 {

   260 	aChunk = new TUsbcScChunkInfo(aLdd);

   248 	aChunk = new TUsbcScChunkInfo(aLdd);

   261 	if (aChunk==NULL)

   249 	if (aChunk==NULL)

   262 		{

   250 		{

   263 		return KErrNoMemory;

   251 		return KErrNoMemory;

   264 		}

   252 		}

   269 		delete aChunk;

   257 		delete aChunk;

   270 		aChunk=NULL;

   258 		aChunk=NULL;

   271 		return r;

   259 		return r;

   272 		}

   260 		}

   273 

   261 

   276 	return KErrNone;

   263 	return KErrNone;

   277 }

   264 }

   278 

   265 

   279 // End TUsbcScChunkInfo

   266 // End TUsbcScChunkInfo

   280 

   267 

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

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

   348 		{

   335 		{

   349 		iBufferStart->iHead= iHead;

   336 		iBufferStart->iHead= iHead;

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

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

   351 		iBufferStart->iBilTail=iHead;

   338 		iBufferStart->iBilTail=iHead;

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

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

   354 		}

   342 		}

   355 }

   343 }

   369 

   344 

   370 /*

   345 /*

   371 TUsbcScBuffer::StartEndpoint

   346 TUsbcScBuffer::StartEndpoint

   372 

   347 

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

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

   374 

   349 

   375 */

   350 */

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

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

   377 	{

   352 	{

   379 	

   354 	

   380 	iCallback=aRequestInfo;

   355 	iCallback=aRequestInfo;

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

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

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

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

   383 	iMode = aFlags;

   358 	iMode = aFlags;

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

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

   387 		{

   361 		{

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

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

   391 		// And Start next read.

   364 		// And Start next read.

   392 		iNeedsPacket=KEpIsStarting;

   365 		iNeedsPacket=KEpIsStarting;

   393 		}

   366 		}

   394 	}

   367 	}

   395 

   368 

   396 

   369 

   397 

   370 

   398 void TUsbcScBuffer::Destroy()

   371 void TUsbcScBuffer::Destroy()

   399 {

   372 {

   402 	Cancel(KErrCancel);

   374 	Cancel(KErrCancel);

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

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

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

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

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

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

   406 		}

   378 		}

   411 

   383 

   412 TInt TUsbcScBuffer::StartDataRead()

   384 TInt TUsbcScBuffer::StartDataRead()

   413 {

   385 {

   414 	if (!iMaxPacketSize)

   386 	if (!iMaxPacketSize)

   415 	{

   387 	{

   418 		return KErrNone;

   389 		return KErrNone;

   419 	}

   390 	}

   420 	if (iStatusList.iState!=ENotRunning) 

   391 	if (iStatusList.iState!=ENotRunning) 

   421 		{

   392 		{

   424 		return KErrNone;

   394 		return KErrNone;

   425 		}

   395 		}

   426 

   396 

   427 	TInt maxLength;

   397 	TInt maxLength;

   428 	TInt freeSpace;

   398 	TInt freeSpace;

   430 

   400 

   431 	// get next request

   401 	// get next request

   432 	TUsbcScStatusElement* nextJob = iStatusList.Next();

   402 	TUsbcScStatusElement* nextJob = iStatusList.Next();

   433 	if (nextJob == NULL)

   403 	if (nextJob == NULL)

   434 		{

   404 		{

   437 		if (iMode && KUsbScCoupledRead)

   406 		if (iMode && KUsbScCoupledRead)

   438 			return KErrEof;

   407 			return KErrEof;

   439 		iStatusList.iState=EReadingAhead;

   408 		iStatusList.iState=EReadingAhead;

   440 		}

   409 		}

   441 	else

   410 	else

   442 		iStatusList.iState=EInProgress;

   411 		iStatusList.iState=EInProgress;

   443 

   412 

   444 	TInt tail = iBufferStart->iTail;

   413 	TInt tail = iBufferStart->iTail;

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

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

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

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

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

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

   448 

   418 

   449 

   419 

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

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

   451 		{

   421 		{

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

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

   455 

   425 

   456 		if (freeSpace<iMinReadSize)

   426 		if (freeSpace<iMinReadSize)

   457 			{

   427 			{

   458 			iStatusList.iState=ENotRunning;

   428 			iStatusList.iState=ENotRunning;

   461 			return KErrOverflow; 				// Read STALL !! !! !!

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

   462 			}

   431 			}

   463 

   432 

   464 		if (freeSpace<maxLength)

   433 		if (freeSpace<maxLength)

   465 			maxLength = freeSpace;

   434 			maxLength = freeSpace;

   466 		}

   435 		}

   467 	if (maxLength> iMaxReadSize) 

   436 	if (maxLength> iMaxReadSize) 

   468 		maxLength =  iMaxReadSize;

   437 		maxLength =  iMaxReadSize;

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

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

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

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

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

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

   472 

   442 

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

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

   474 	// set up callback stucture

   444 	// set up callback stucture

   475 

   445 

   477 	TInt r;

   447 	TInt r;

   478 	// Go!!

   448 	// Go!!

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

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

   480 	if (r!=KErrNone)

   450 	if (r!=KErrNone)

   481 		{

   451 		{

   483 		iStatusList.Complete(r);

   453 		iStatusList.Complete(r);

   484 		}

   454 		}

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

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

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

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

   487 	return KErrNone;

   457 	return KErrNone;

   488 }

   458 }

   489 

   459 

   490 

   460 

   491 void TUsbcScBuffer::CompleteRead(TBool aStartNextRead)

   461 void TUsbcScBuffer::CompleteRead(TBool aStartNextRead)

   492 {

   462 {

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

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

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

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

   497 	const TInt packetCount = iCallback->iRxPackets;

   467 	const TInt packetCount = iCallback->iRxPackets;

   498  	iCallback->iRxPackets=0;

   468  	iCallback->iRxPackets=0;

   499 	TUint flags = 0;

   469 	TUint flags = 0;

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

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

   509 

   479 

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

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

   511 	{

   481 	{

   512 

   482 

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

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

   516 	TLinAddr dummy;

   486 	TLinAddr dummy;

   518 	// Find iNext

   489 	// Find iNext

   519 

   490 

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

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

   521 	TInt maxLength; 

   492 	TInt maxLength; 

   522 

   493 

   525 		{

   496 		{

   526 		// round up.

   497 		// round up.

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

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

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

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

   529 

   500 

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

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

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

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

   534 			{

   504 			{

   535 			next = iFirstPacket;

   505 			next = iFirstPacket;

   536 			continue;

   506 			continue;

   537 			}

   507 			}

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

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

   539 		if (maxLength<iMinReadSize) 

   509 		if (maxLength<iMinReadSize) 

   540 			{

   510 			{

   541 			next+=maxLength;

   511 			next+=maxLength;

   544 			continue;

   513 			continue;

   545 			}

   514 			}

   546 		}

   515 		}

   547 	while (EFalse);

   516 	while (EFalse);

   548 

   517 

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

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

   552 

   521 

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

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

   554 	

   523 	

   555 // Create Header

   524 // Create Header

   561 	header->iBytes=aByteCount;

   530 	header->iBytes=aByteCount;

   562 	header->iNext=next;

   531 	header->iNext=next;

   563 	header->iAltSettingSeq=iLdd->iAsSeq;

   532 	header->iAltSettingSeq=iLdd->iAsSeq;

   564 	header->iAltSetting=iLdd->iAlternateSetting;

   533 	header->iAltSetting=iLdd->iAlternateSetting;

   565 	header->iFlags=aFlags;

   534 	header->iFlags=aFlags;

   568 	iStatusList.iState=ENotRunning;

   537 	iStatusList.iState=ENotRunning;

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

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

   570 		{

   539 		{

   571 			iStalled=next;

   540 			iStalled=next;

   572 		}

   541 		}

   573 	else

   542 	else

   574 		{

   543 		{

   575 

   544 

   577 		TInt oldHead=iHead;

   546 		TInt oldHead=iHead;

   578 		iHead = next;

   547 		iHead = next;

   579 

   548 

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

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

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

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

   593 				}

   562 				}

   594 			}

   563 			}

   595 		else

   564 		else

   596 			{

   565 			{

   597 			iBufferStart->iHead = next;

   566 			iBufferStart->iHead = next;

   600 			}

   568 			}

   601 		// Complete userside

   569 		// Complete userside

   602 		iStatusList.Complete();

   570 		iStatusList.Complete();

   603 		}  

   571 		}  

   604 	}

   572 	}

   618 	// Add alt setting change packet.

   586 	// Add alt setting change packet.

   619 

   587 

   620 

   588 

   621 	if (StartDataRead() == KErrOverflow)

   589 	if (StartDataRead() == KErrOverflow)

   622 	{

   590 	{

   625 	}

   592 	}

   626 

   593 

   627 	iBufferStart->iHead = iHead;

   594 	iBufferStart->iHead = iHead;

   628 	}

   595 	}

   629 

   596 

   630 

   597 

   631 

   598 

   632 void TUsbcScBuffer::StartDataWrite()

   599 void TUsbcScBuffer::StartDataWrite()

   633 	{

   600 	{

   634 	

   601 	

   637 	TUsbcScStatusElement* nextJob = iStatusList.Next();

   603 	TUsbcScStatusElement* nextJob = iStatusList.Next();

   638 	TBool zlpReqd;

   604 	TBool zlpReqd;

   639 	TInt length;

   605 	TInt length;

   640 	TUint start;

   606 	TUint start;

   641 	TUint8* startAddr;

   607 	TUint8* startAddr;

   642 	TInt maxLength;

   608 	TInt maxLength;

   643 	TPhysAddr physAddr;

   609 	TPhysAddr physAddr;

   644 	TInt r;

   610 	TInt r;

   645 	if (!iMaxPacketSize)

   611 	if (!iMaxPacketSize)

   646 	{

   612 	{

   648 		return;

   614 		return;

   649 	}

   615 	}

   650 

   616 

   651 	if (nextJob == NULL)

   617 	if (nextJob == NULL)

   652 		{

   618 		{

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

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

   655 			{

   621 			{

   657 			// Start other read again.

   623 			// Start other read again.

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

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

   659 			}

   625 			}

   660 		}

   626 		}

   661 	else

   627 	else

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

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

   693 		iCallback->iZlpReqd = zlpReqd;

   659 		iCallback->iZlpReqd = zlpReqd;

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

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

   695 		if (r!=KErrNone)

   661 		if (r!=KErrNone)

   696 			{

   662 			{

   699 			iStatusList.Complete(r);

   664 			iStatusList.Complete(r);

   700 			}

   665 			}

   701 		}

   666 		}

   702 

   667 

   703 	}

   668 	}

   704 

   669 

   705 void TUsbcScBuffer::CompleteWrite()

   670 void TUsbcScBuffer::CompleteWrite()

   706 	{

   671 	{

   707 	TInt error = iCallback->iError;

   672 	TInt error = iCallback->iError;

   709 	iSent+= iCallback->iTxBytes;

   674 	iSent+= iCallback->iTxBytes;

   710 

   675 

   711 	// More to send?

   676 	// More to send?

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

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

   713 		{

   678 		{

   753 		}

   718 		}

   754 	}

   719 	}

   755 

   720 

   756 void TUsbcScBuffer::SendEp0StatusPacket(TInt aState)

   721 void TUsbcScBuffer::SendEp0StatusPacket(TInt aState)

   757 {

   722 {

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

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

   761 	// another after we have added out packet.  

   726 	// another after we have added out packet.  

   762 	Ep0CancelLddRead();

   727 	Ep0CancelLddRead();

   763 

   728 

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

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

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

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

   824 	}

   789 	}

   825 

   790 

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

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

   827 	{

   792 	{

   830 	if (iLength<iSize)

   794 	if (iLength<iSize)

   831 		{

   795 		{

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

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

   833 		e.iStatus = aStatus;

   797 		e.iStatus = aStatus;

   834 		e.iLength = aLength;

   798 		e.iLength = aLength;

   835 		e.iStart = aStart;

   799 		e.iStart = aStart;

   836 		e.iFlags = aFlags;

   800 		e.iFlags = aFlags;

   837 		iLength++;

   801 		iLength++;

   840 		return KErrNone;

   804 		return KErrNone;

   841 		}

   805 		}

   842 	else

   806 	else

   843 		return KErrInUse;

   807 		return KErrInUse;

   844 	}

   808 	}

   881 

   845 

   882 TInt TUsbcScStatusList::Complete(TInt aError)

   846 TInt TUsbcScStatusList::Complete(TInt aError)

   883 	{

   847 	{

   884 	if (iState==ENotRunning)

   848 	if (iState==ENotRunning)

   885 		{

   849 		{

   888 		}

   851 		}

   889  	else

   852  	else

   890 		{

   853 		{

   891 		iState=ENotRunning;

   854 		iState=ENotRunning;

   892 		if (iLength==0)

   855 		if (iLength==0)

   908 

   871 

   909 void TUsbcScStatusList::Complete()

   872 void TUsbcScStatusList::Complete()

   910 	{

   873 	{

   911 	if (iLength==0)

   874 	if (iLength==0)

   912 		return;

   875 		return;

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

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

   916 

   879 

   917 	iLength--;

   880 	iLength--;

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

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

   923 	}

   882 	}

   924 

   883 

   925 // End TUsbcScStatusList

   884 // End TUsbcScStatusList

   926 

   885 

   927 /*****************************************************************************\

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

   946 	iAlternateSettingList = aAlternateSettingList;

   905 	iAlternateSettingList = aAlternateSettingList;

   947 	iMaxEndpoints=0;

   906 	iMaxEndpoints=0;

   948 	iTotalSize   =0;

   907 	iTotalSize   =0;

   949 	iTotalBuffers=0;

   908 	iTotalBuffers=0;

   950 	iAltSettings =0;

   909 	iAltSettings =0;

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

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

   954 

   912 

   955 	if (iAlternateSettingList)

   913 	if (iAlternateSettingList)

   956 		{

   914 		{

   957 		TUsbcScAlternateSetting* alt = iAlternateSettingList->iHead;

   915 		TUsbcScAlternateSetting* alt = iAlternateSettingList->iHead;

   964 			alt = alt->iNext;

   922 			alt = alt->iNext;

   965 			};

   923 			};

   966 		}

   924 		}

   967 	

   925 	

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

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

   971 	TInt inout;

   928 	TInt inout;

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

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

   973 		{

   930 		{

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

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

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

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

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

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

   988 //

   945 //

   989 

   946 

   990 TInt TRealizeInfo::CopyAndSortEndpoints()

   947 TInt TRealizeInfo::CopyAndSortEndpoints()

   991 	{

   948 	{

   993 

   950 

   994 	TInt altSetting = 0;

   951 	TInt altSetting = 0;

   995 	TInt endpointOffs;

   952 	TInt endpointOffs;

   996 	TInt endpoint;

   953 	TInt endpoint;

   997 	TInt altEp;

   954 	TInt altEp;

  1002 

   959 

  1003 	if (iAlternateSettingList)

   960 	if (iAlternateSettingList)

  1004 		{

   961 		{

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

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

  1006 			{		

   963 			{		

  1009 			iBufs[KUsbcScIn].iEps =0;

   966 			iBufs[KUsbcScIn].iEps =0;

  1010 			iBufs[KUsbcScOut].iEps =0;

   967 			iBufs[KUsbcScOut].iEps =0;

  1011 

   968 

  1012 			// For alt setting, iterate eps

   969 			// For alt setting, iterate eps

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

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

  1014 				{

   971 				{

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

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

  1017 

   975 

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

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

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

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

  1022 				if (inout==KUsbcScUnknown)

   980 				if (inout==KUsbcScUnknown)

  1023 					{

   981 					{

  1026 					return KErrArgument;

   983 					return KErrArgument;

  1027 					}

   984 					}

  1028 

   985 

  1029 				bufsd = &(iBufs[inout]);

   986 				bufsd = &(iBufs[inout]);

  1031 

   989 

  1032 				// find and position ep, and insert.

   990 				// find and position ep, and insert.

  1033 

   991 

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

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

  1035 					{

   993 					{

  1038 					endpointOffs = altSetting*iMaxEndpoints;

   995 					endpointOffs = altSetting*iMaxEndpoints;

  1039 					bufsd->iEp[endpointOffs] = nextEp;

   996 					bufsd->iEp[endpointOffs] = nextEp;

  1040 					}

   997 					}

  1041 				else

   998 				else

  1042 					{

   999 					{

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

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

  1046 						{

  1003 						{

  1047 						endpointOffs = altSetting*iMaxEndpoints + endpoint;

  1004 						endpointOffs = altSetting*iMaxEndpoints + endpoint;

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

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

  1049 							{

  1006 							{

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

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

  1052 							}

  1010 							}

  1053 						else

  1011 						else

  1054 							{

  1012 							{

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

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

  1057 							placed = ETrue;

  1016 							placed = ETrue;

  1058 							break;

  1017 							break;

  1059 							}

  1018 							}

  1060 						} // end for endpoint

  1019 						} // end for endpoint

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

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

  1077 // required.

  1036 // required.

  1078 

  1037 

  1079 void TRealizeInfo::CalcBuffSizes()

  1038 void TRealizeInfo::CalcBuffSizes()

  1080 	{

  1039 	{

  1083 	TInt endpoint;

  1042 	TInt endpoint;

  1084 	TInt inout;

  1043 	TInt inout;

  1085 	TInt altSetting;

  1044 	TInt altSetting;

  1086 	TUsbcScEndpoint* nextEp;

  1045 	TUsbcScEndpoint* nextEp;

  1087 	TInt bufferSize;

  1046 	TInt bufferSize;

  1088 	TEndpointSortBufs* bufsd;

  1047 	TEndpointSortBufs* bufsd;

  1089 

  1048 

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

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

  1091 		{

  1050 		{

  1093 

  1053 

  1094 		bufsd = &(iBufs[inout]);

  1054 		bufsd = &(iBufs[inout]);

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

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

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

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

  1097 			{

  1057 			{

  1099 			TInt bufMaxSize=0;

  1059 			TInt bufMaxSize=0;

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

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

  1101 				{

  1061 				{

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

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

  1104 				if (nextEp!=NULL)

  1064 				if (nextEp!=NULL)

  1105 					{

  1065 					{

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

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

  1108 					if (bufferSize> bufMaxSize)

  1068 					if (bufferSize> bufMaxSize)

  1109 						 bufMaxSize = bufferSize;

  1069 						 bufMaxSize = bufferSize;

  1110 					}

  1070 					}

  1111 				} // for altsetting

  1071 				} // for altsetting

  1113 			bufsd->iSizes[endpoint] = bufMaxSize;

  1073 			bufsd->iSizes[endpoint] = bufMaxSize;

  1114 			if (bufMaxSize>0) 

  1074 			if (bufMaxSize>0) 

  1115 				{

  1075 				{

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

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

  1117 				iTotalBuffers++;

  1077 				iTotalBuffers++;

  1160 	iAltSettingsTbl->iEpRecordSize = sizeof(TUint);

  1120 	iAltSettingsTbl->iEpRecordSize = sizeof(TUint);

  1161 	iAltSettingsTbl->iNumOfAltSettings = iAltSettings;

  1121 	iAltSettingsTbl->iNumOfAltSettings = iAltSettings;

  1162 

  1122 

  1163 

  1123 

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

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

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

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

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

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

  1169 

  1131 

  1170 	TInt* noEpForAlt;

  1132 	TInt* noEpForAlt;

  1171 	TInt altSetting;

  1133 	TInt altSetting;

  1173 	if (iAlternateSettingList)

  1135 	if (iAlternateSettingList)

  1174 		{

  1136 		{

  1175 		alt = iAlternateSettingList->iHead;

  1137 		alt = iAlternateSettingList->iHead;

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

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

  1177 			{

  1139 			{

  1179 				iAltSettingsTbl->iAltTableOffset[altSetting] = tableOffset;

  1142 				iAltSettingsTbl->iAltTableOffset[altSetting] = tableOffset;

  1180 				noEpForAlt = (TInt*) &aChunkInfo->iChunkMem[tableOffset];

  1143 				noEpForAlt = (TInt*) &aChunkInfo->iChunkMem[tableOffset];

  1181 			 

  1144 			 

  1182 				*noEpForAlt = alt->iNumberOfEndpoints;  // Set NumberofEndpoints field in Altsetting table

  1145 				*noEpForAlt = alt->iNumberOfEndpoints;  // Set NumberofEndpoints field in Altsetting table

  1183 				tableOffset+= sizeof(TInt)+ alt->iNumberOfEndpoints*sizeof(TUsbcScHdrEndpointRecord);

  1146 				tableOffset+= sizeof(TInt)+ alt->iNumberOfEndpoints*sizeof(TUsbcScHdrEndpointRecord);

  1224 	  iChunkInfo(NULL),

  1187 	  iChunkInfo(NULL),

  1225 	  iNumBuffers(-1),

  1188 	  iNumBuffers(-1),

  1226 	  iBuffers(NULL),

  1189 	  iBuffers(NULL),

  1227 	  iEp0Endpoint(NULL)

  1190 	  iEp0Endpoint(NULL)

  1228 	{

  1191 	{

  1231 	iClient = &Kern::CurrentThread();

  1193 	iClient = &Kern::CurrentThread();

  1232 	iClient->Open();

  1194 	iClient->Open();

  1233 	for (TInt i = 1; i < KUsbcMaxRequests; i++)

  1195 	for (TInt i = 1; i < KUsbcMaxRequests; i++)

  1234 		{

  1196 		{

  1235 		iRequestStatus[i] = NULL;

  1197 		iRequestStatus[i] = NULL;

  1241 // Destructor

  1203 // Destructor

  1242 //

  1204 //

  1243 

  1205 

  1244 DLddUsbcScChannel::~DLddUsbcScChannel()

  1206 DLddUsbcScChannel::~DLddUsbcScChannel()

  1245 	{

  1207 	{

  1247 	if (iController)

  1209 	if (iController)

  1248 		{

  1210 		{

  1249 		iController->DeRegisterClient(this);

  1211 		iController->DeRegisterClient(this);

  1250 		iStatusCallbackInfo.Cancel();

  1212 		iStatusCallbackInfo.Cancel();

  1251 		iEndpointStatusCallbackInfo.Cancel();

  1213 		iEndpointStatusCallbackInfo.Cancel();

  1262 		if (iStatusFifo!=NULL)

  1224 		if (iStatusFifo!=NULL)

  1263 			{

  1225 			{

  1264 			delete iStatusFifo;

  1226 			delete iStatusFifo;

  1265 			}

  1227 			}

  1266 		}

  1228 		}

  1268 	if (iBuffers)

  1230 	if (iBuffers)

  1269 		{

  1231 		{

  1270 		TInt i;

  1232 		TInt i;

  1271 		for (i=0; i<(iNumBuffers+2); i++) 

  1233 		for (i=0; i<(iNumBuffers+2); i++) 

  1272 			{

  1234 			{

  1276 		}

  1238 		}

  1277 

  1239 

  1278 	if (iRealizeCalled)

  1240 	if (iRealizeCalled)

  1279 		{

  1241 		{

  1280 		// Close Chunk

  1242 		// Close Chunk

  1282 		iChunkInfo->Close();

  1243 		iChunkInfo->Close();

  1283 		// ChunkInfo will delete itself with DFC, but the pointer here is no longer needed.		

  1244 		// ChunkInfo will delete itself with DFC, but the pointer here is no longer needed.		

  1284 		iChunkInfo=NULL;

  1245 		iChunkInfo=NULL;

  1285 		}

  1246 		}

  1287 	Kern::SafeClose((DObject*&)iClient, NULL);

  1248 	Kern::SafeClose((DObject*&)iClient, NULL);

  1289 	}

  1249 	}

  1290 

  1250 

  1291 

  1251 

  1292 //

  1252 //

  1293 // DoCreate - Create channel

  1253 // DoCreate - Create channel

  1294 //

  1254 //

  1295 

  1255 

  1296 TInt DLddUsbcScChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer)

  1256 TInt DLddUsbcScChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer)

  1297 	{

  1257 	{

  1301 	if (!Kern::CurrentThreadHasCapability(ECapabilityCommDD,

  1260 	if (!Kern::CurrentThreadHasCapability(ECapabilityCommDD,

  1302 										  __PLATSEC_DIAGNOSTIC_STRING("Checked by USBCSC.LDD (USB Driver)")))

  1261 										  __PLATSEC_DIAGNOSTIC_STRING("Checked by USBCSC.LDD (USB Driver)")))

  1303 		{

  1262 		{

  1304 		return KErrPermissionDenied;

  1263 		return KErrPermissionDenied;

  1305 		}

  1264 		}

  1355 

  1314 

  1356 void DLddUsbcScChannel::HandleMsg(TMessageBase* aMsg)

  1315 void DLddUsbcScChannel::HandleMsg(TMessageBase* aMsg)

  1357 	{

  1316 	{

  1358 	TThreadMessage& m = *(TThreadMessage*)aMsg;

  1317 	TThreadMessage& m = *(TThreadMessage*)aMsg;

  1359 	TInt id = m.iValue;

  1318 	TInt id = m.iValue;

  1362 	if (id == (TInt) ECloseMsg)

  1321 	if (id == (TInt) ECloseMsg)

  1363 		{

  1322 		{

  1364 		iChannelClosing = ETrue;

  1323 		iChannelClosing = ETrue;

  1365 		m.Complete(KErrNone, EFalse);

  1324 		m.Complete(KErrNone, EFalse);

  1366 		return;

  1325 		return;

  1367 		}

  1326 		}

  1368 

  1327 

  1369 	TInt r;

  1328 	TInt r;

  1375 	if (id < 0)

  1329 	if (id < 0)

  1376 		{

  1330 		{

  1377 		// DoRequest

  1331 		// DoRequest

  1378 		TRequestStatus* pS = (TRequestStatus*) m.Ptr0();

  1332 		TRequestStatus* pS = (TRequestStatus*) m.Ptr0();

  1379 		r = DoRequest(~id, pS, m.Ptr1(), m.Ptr2());

  1333 		r = DoRequest(~id, pS, m.Ptr1(), m.Ptr2());

  1393 		}

  1347 		}

  1394 	}

  1348 	}

  1395 // end HandleMsg.

  1349 // end HandleMsg.

  1396 

  1350 

  1397 

  1351 

  1398 //

  1354 //

  1399 // DoRequest - Asynchronous requests

  1355 // DoRequest - Asynchronous requests

  1400 //

  1356 //

  1401 // Overrides pure virtual, called by HandleMsg. (Above)

  1357 // Overrides pure virtual, called by HandleMsg. (Above)

  1402 //

  1358 //

  1404 	{

  1360 	{

  1405 	TInt reqNo = aReqNo & RDevUsbcScClient::KFieldIdMask;

  1361 	TInt reqNo = aReqNo & RDevUsbcScClient::KFieldIdMask;

  1406 	TInt r = KErrNone;  // return via request notify

  1362 	TInt r = KErrNone;  // return via request notify

  1407 	TBool needsCompletion =EFalse;

  1363 	TBool needsCompletion =EFalse;

  1408 

  1364 

  1411 	if ((reqNo>RDevUsbcScClient::ERequestReadDataNotify) &&

  1367 	if ((reqNo>RDevUsbcScClient::ERequestReadDataNotify) &&

  1412 		(reqNo<RDevUsbcScClient::ERequestMaxRequests))

  1368 		(reqNo<RDevUsbcScClient::ERequestMaxRequests))

  1413 		{

  1369 		{

  1414 		if (iRequestStatus[reqNo])

  1370 		if (iRequestStatus[reqNo])

  1415 			{

  1371 			{

  1422 	switch (reqNo)

  1378 	switch (reqNo)

  1423 		{

  1379 		{

  1424 	case RDevUsbcScClient::ERequestWriteData:

  1380 	case RDevUsbcScClient::ERequestWriteData:

  1425 		{

  1381 		{

  1426 		TInt buffer =  (aReqNo>>RDevUsbcScClient::KFieldBuffPos)&RDevUsbcScClient::KFieldBuffMask;

  1382 		TInt buffer =  (aReqNo>>RDevUsbcScClient::KFieldBuffPos)&RDevUsbcScClient::KFieldBuffMask;

  1434 

  1385 

  1435 		r = DoWriteData( aStatus, buffer, (TInt) a1 /*Start*/, (TInt) a2 /* Length */,

  1386 		r = DoWriteData( aStatus, buffer, (TInt) a1 /*Start*/, (TInt) a2 /* Length */,

  1436 						 aReqNo>>RDevUsbcScClient::KFieldFlagsPos ); // Flags

  1387 						 aReqNo>>RDevUsbcScClient::KFieldFlagsPos ); // Flags

  1437 		break;

  1388 		break;

  1438 		}

  1389 		}

  1439 	case RDevUsbcScClient::ERequestReadDataNotify:

  1390 	case RDevUsbcScClient::ERequestReadDataNotify:

  1440 		{

  1391 		{

  1442 		return DoReadDataNotify(aStatus, (TInt) a1, (TInt) a2); // a1 = aBufferNumber, a2 - aLength;

  1393 		return DoReadDataNotify(aStatus, (TInt) a1, (TInt) a2); // a1 = aBufferNumber, a2 - aLength;

  1443 		} 

  1394 		} 

  1444 

  1395 

  1445 	case RDevUsbcScClient::ERequestAlternateDeviceStatusNotify:

  1396 	case RDevUsbcScClient::ERequestAlternateDeviceStatusNotify:

  1446 		{

  1397 		{

  1454 		iDeviceStatusNeeded = ETrue;

  1400 		iDeviceStatusNeeded = ETrue;

  1455 		iStatusChangePtr = a1;

  1401 		iStatusChangePtr = a1;

  1456 		needsCompletion = AlternateDeviceStateTestComplete();

  1402 		needsCompletion = AlternateDeviceStateTestComplete();

  1457 		break;

  1403 		break;

  1458 		}

  1404 		}

  1459 	case RDevUsbcScClient::ERequestReEnumerate:

  1405 	case RDevUsbcScClient::ERequestReEnumerate:

  1460 		{

  1406 		{

  1462 		// If successful, this will complete via the status notification.

  1408 		// If successful, this will complete via the status notification.

  1463 		r = iController->ReEnumerate();

  1409 		r = iController->ReEnumerate();

  1464 		break;

  1410 		break;

  1465 		}

  1411 		}

  1466 	case RDevUsbcScClient::ERequestEndpointStatusNotify:

  1412 	case RDevUsbcScClient::ERequestEndpointStatusNotify:

  1467 		{

  1413 		{

  1475 		iEndpointStatusChangePtr = a1;

  1417 		iEndpointStatusChangePtr = a1;

  1476 		break;

  1418 		break;

  1477 		}

  1419 		}

  1478 	case RDevUsbcScClient::ERequestOtgFeaturesNotify:

  1420 	case RDevUsbcScClient::ERequestOtgFeaturesNotify:

  1479 		{

  1421 		{

  1487 		iOtgFeatureChangePtr = a1;

  1425 		iOtgFeatureChangePtr = a1;

  1488 		break;

  1426 		break;

  1489 		}

  1427 		}

  1490     default:

  1428     default:

  1491 		r = KErrNotSupported;

  1429 		r = KErrNotSupported;

  1506 //

  1444 //

  1507 // This method sets up the request to facilitate the userside being notifed when new data has been read.

  1445 // This method sets up the request to facilitate the userside being notifed when new data has been read.

  1508 //

  1446 //

  1509 TInt DLddUsbcScChannel::DoReadDataNotify(TRequestStatus* aStatus, TInt aBufferNum, TInt aLength)

  1447 TInt DLddUsbcScChannel::DoReadDataNotify(TRequestStatus* aStatus, TInt aBufferNum, TInt aLength)

  1510 	{

  1448 	{

  1513 	TInt r = KErrNone;

  1450 	TInt r = KErrNone;

  1514 	// check range

  1451 	// check range

  1515 	if ((aBufferNum<0) ||  (aBufferNum>=iNumBuffers))  // Indirectly checks that we are set up.

  1452 	if ((aBufferNum<0) ||  (aBufferNum>=iNumBuffers))  // Indirectly checks that we are set up.

  1516 		{

  1453 		{

  1517 		if (aBufferNum!=KUsbcScEndpointZero)

  1454 		if (aBufferNum!=KUsbcScEndpointZero)

  1518 			{

  1455 			{

  1521 			return KErrArgument;

  1457 			return KErrArgument;

  1522 			}

  1458 			}

  1523 		else

  1459 		else

  1524 			{

  1460 			{

  1525 			aBufferNum = iEP0OutBuff;

  1461 			aBufferNum = iEP0OutBuff;

  1528 	else

  1464 	else

  1529 		{

  1465 		{

  1530 		// check direction

  1466 		// check direction

  1531 		if (iBuffers[aBufferNum].iDirection!=KUsbcScOut)

  1467 		if (iBuffers[aBufferNum].iDirection!=KUsbcScOut)

  1532 			{

  1468 			{

  1534 			return KErrNotSupported;

  1470 			return KErrNotSupported;

  1535 			}

  1471 			}

  1536 		if (!Configured())

  1472 		if (!Configured())

  1537 			return KErrUsbInterfaceNotReady;

  1473 			return KErrUsbInterfaceNotReady;

  1538 		}

  1474 		}

  1539 	SUsbcScBufferHeader* scBuffer = (SUsbcScBufferHeader*) iBuffers[aBufferNum].iBufferStart;

  1475 	SUsbcScBufferHeader* scBuffer = (SUsbcScBufferHeader*) iBuffers[aBufferNum].iBufferStart;

  1540 

  1476 

  1542 	if (iBuffers[aBufferNum].iHead != scBuffer->iBilTail)

  1479 	if (iBuffers[aBufferNum].iHead != scBuffer->iBilTail)

  1543 		r = KErrCompletion;

  1480 		r = KErrCompletion;

  1544 	else

  1481 	else

  1545 		if (iBuffers[aBufferNum].iStalled)

  1482 		if (iBuffers[aBufferNum].iStalled)

  1546 			{

  1483 			{

  1554 		{

  1491 		{

  1555 		iBuffers[aBufferNum].StartDataRead();

  1492 		iBuffers[aBufferNum].StartDataRead();

  1556 		}

  1493 		}

  1557 	else

  1494 	else

  1558 		{

  1495 		{

  1560 		}

  1497 		}

  1561 	return r;

  1498 	return r;

  1562 	}

  1499 	}

  1563 // end DoReadDataNotify.

  1500 // end DoReadDataNotify.

  1564 

  1501 

  1569 //

  1506 //

  1570 // This method sets up the request to write data to USB from userside.

  1507 // This method sets up the request to write data to USB from userside.

  1571 //

  1508 //

  1572 TInt DLddUsbcScChannel::DoWriteData(TRequestStatus* aStatus,TInt aBufferNum, TUint aStart, TUint aLength, TUint aFlags)

  1509 TInt DLddUsbcScChannel::DoWriteData(TRequestStatus* aStatus,TInt aBufferNum, TUint aStart, TUint aLength, TUint aFlags)

  1573 	{

  1510 	{

  1576 	if (!iUserKnowsAltSetting)

  1512 	if (!iUserKnowsAltSetting)

  1577 		return KErrEof;

  1513 		return KErrEof;

  1578 	// Check Buffer Number

  1514 	// Check Buffer Number

  1579 	if ((aBufferNum<0) ||  (aBufferNum>=iNumBuffers))

  1515 	if ((aBufferNum<0) ||  (aBufferNum>=iNumBuffers))

  1580 		{

  1516 		{

  1581 		if ((TUint)aBufferNum!=RDevUsbcScClient::KFieldBuffMask)  // KUsbcScEndpointZero & KFieldBuffMas = KFieldBuffMas;

  1517 		if ((TUint)aBufferNum!=RDevUsbcScClient::KFieldBuffMask)  // KUsbcScEndpointZero & KFieldBuffMas = KFieldBuffMas;

  1582 			{

  1518 			{

  1584 			return KErrArgument;

  1520 			return KErrArgument;

  1585 			}

  1521 			}

  1586 		else

  1522 		else

  1587 			{

  1523 			{

  1588 			aBufferNum = iEP0InBuff;

  1524 			aBufferNum = iEP0InBuff;

  1591 	else

  1527 	else

  1592 		{

  1528 		{

  1593 		// check direction

  1529 		// check direction

  1594 		if (iBuffers[aBufferNum].iDirection!=KUsbcScIn)

  1530 		if (iBuffers[aBufferNum].iDirection!=KUsbcScIn)

  1595 			{

  1531 			{

  1597 				return KErrArgument;

  1533 				return KErrArgument;

  1598 			}

  1534 			}

  1599 		}

  1535 		}

  1600 

  1536 

  1601 	TUsbcScBuffer& buf=iBuffers[aBufferNum];

  1537 	TUsbcScBuffer& buf=iBuffers[aBufferNum];

  1602 

  1538 

  1603 	if ((aStart< (((TLinAddr) buf.iBufferStart)-buf.iChunkAddr)) || ((aStart+aLength)>iBuffers[aBufferNum].iBufferEnd))

  1539 	if ((aStart< (((TLinAddr) buf.iBufferStart)-buf.iChunkAddr)) || ((aStart+aLength)>iBuffers[aBufferNum].iBufferEnd))

  1604 		{

  1540 		{

  1606 		return KErrArgument;

  1542 		return KErrArgument;

  1607 		}

  1543 		}

  1608 

  1544 

  1609 	if ( (aBufferNum != iEP0InBuff) && !Configured())

  1545 	if ( (aBufferNum != iEP0InBuff) && !Configured())

  1610 		return KErrUsbInterfaceNotReady;

  1546 		return KErrUsbInterfaceNotReady;

  1611 

  1547 

  1612 	if (aStart & ~buf.iAlignMask)

  1548 	if (aStart & ~buf.iAlignMask)

  1613 		{

  1549 		{

  1616 		return KErrArgument;

  1551 		return KErrArgument;

  1617 		}

  1552 		}

  1618 			

  1553 			

  1619 	TInt r = iBuffers[aBufferNum].iStatusList.Add(aStatus, aLength, aStart, aFlags); //update

  1554 	TInt r = iBuffers[aBufferNum].iStatusList.Add(aStatus, aLength, aStart, aFlags); //update

  1620 

  1555 

  1622 		{

  1557 		{

  1623 			iBuffers[aBufferNum].StartDataWrite();

  1558 			iBuffers[aBufferNum].StartDataWrite();

  1624 		}

  1559 		}

  1625 	else

  1560 	else

  1626 		{	

  1561 		{	

  1628 		}

  1563 		}

  1629 

  1564 

  1630 

  1565 

  1631 	return r;

  1566 	return r;

  1632 	}

  1567 	}

  1639 TInt DLddUsbcScChannel::DoCancel(TInt aReqNo, TUint aBuff, TUint aSpair)

  1574 TInt DLddUsbcScChannel::DoCancel(TInt aReqNo, TUint aBuff, TUint aSpair)

  1640 	{

  1575 	{

  1641 	TInt r = KErrNone;

  1576 	TInt r = KErrNone;

  1642 	TInt direction=KUsbcScOut;

  1577 	TInt direction=KUsbcScOut;

  1643 

  1578 

  1646 	switch (aReqNo)

  1580 	switch (aReqNo)

  1647 		{

  1581 		{

  1648 	case RDevUsbcScClient::ERequestCancel:

  1582 	case RDevUsbcScClient::ERequestCancel:

  1649 		TInt buffer;

  1583 		TInt buffer;

  1650 		TInt mask;

  1584 		TInt mask;

  1657 

  1591 

  1658 	// coverity[missing_break]

  1592 	// coverity[missing_break]

  1659 	case RDevUsbcScClient::ERequestWriteDataCancel:

  1593 	case RDevUsbcScClient::ERequestWriteDataCancel:

  1660 		direction = KUsbcScIn;

  1594 		direction = KUsbcScIn;

  1661 	case RDevUsbcScClient::ERequestReadDataNotifyCancel:

  1595 	case RDevUsbcScClient::ERequestReadDataNotifyCancel:

  1663 		if (((TInt)aBuff)==KUsbcScEndpointZero) // EP0 is bi-directional, so pick correct buffer for call type

  1598 		if (((TInt)aBuff)==KUsbcScEndpointZero) // EP0 is bi-directional, so pick correct buffer for call type

  1664 			{

  1599 			{

  1666 			iEp0Endpoint->AbortTransfer();

  1601 			iEp0Endpoint->AbortTransfer();

  1667 			if (direction==KUsbcScIn)

  1602 			if (direction==KUsbcScIn)

  1668 				aBuff=iEP0InBuff;

  1603 				aBuff=iEP0InBuff;

  1669 			else

  1604 			else

  1670 				aBuff=iEP0OutBuff;

  1605 				aBuff=iEP0OutBuff;

  1671 			} 

  1606 			} 

  1672 		else if ((TInt)aBuff >= iNumBuffers) // check buff no range.

  1607 		else if ((TInt)aBuff >= iNumBuffers) // check buff no range.

  1673 			{

  1608 			{

  1675 			return KErrArgument;

  1610 			return KErrArgument;

  1676 			}

  1611 			}

  1677 

  1612 

  1678 		if ((iBuffers[aBuff].iDirection&1)!=direction) // Does direction match call type?

  1613 		if ((iBuffers[aBuff].iDirection&1)!=direction) // Does direction match call type?

  1679 			{

  1614 			{

  1681 			return KErrArgument;

  1616 			return KErrArgument;

  1682 			}	

  1617 			}	

  1683 		iBuffers[aBuff].iStatusList.CancelQueued();

  1618 		iBuffers[aBuff].iStatusList.CancelQueued();

  1684 		iBuffers[aBuff].Cancel(KErrCancel);

  1619 		iBuffers[aBuff].Cancel(KErrCancel);

  1685 		

  1620 		

  1686 		return KErrNone;

  1621 		return KErrNone;

  1687 

  1622 

  1688 	case RDevUsbcScClient::ERequestAlternateDeviceStatusNotifyCancel:

  1623 	case RDevUsbcScClient::ERequestAlternateDeviceStatusNotifyCancel:

  1690 		iDeviceStatusNeeded = EFalse;

  1625 		iDeviceStatusNeeded = EFalse;

  1691 		iStatusFifo->FlushQueue();

  1626 		iStatusFifo->FlushQueue();

  1692 		if (iStatusChangePtr)

  1627 		if (iStatusChangePtr)

  1693 			{

  1628 			{

  1694 			TInt deviceState = iController->GetDeviceStatus();

  1629 			TInt deviceState = iController->GetDeviceStatus();

  1698 			iStatusChangePtr = NULL; 

  1633 			iStatusChangePtr = NULL; 

  1699 			}

  1634 			}

  1700 	break;

  1635 	break;

  1701 

  1636 

  1702 	case RDevUsbcScClient::ERequestReEnumerateCancel:

  1637 	case RDevUsbcScClient::ERequestReEnumerateCancel:

  1704 	break;

  1639 	break;

  1705 

  1640 

  1706 	case RDevUsbcScClient::ERequestEndpointStatusNotifyCancel:

  1641 	case RDevUsbcScClient::ERequestEndpointStatusNotifyCancel:

  1708 		CancelNotifyEndpointStatus();

  1643 		CancelNotifyEndpointStatus();

  1709 	break;

  1644 	break;

  1710 

  1645 

  1711  	case RDevUsbcScClient::ERequestOtgFeaturesNotifyCancel:

  1646  	case RDevUsbcScClient::ERequestOtgFeaturesNotifyCancel:

  1713 		CancelNotifyOtgFeatures();

  1648 		CancelNotifyOtgFeatures();

  1714 	break;

  1649 	break;

  1715 

  1650 

  1716 	default:

  1651 	default:

  1718 		return KErrArgument;

  1653 		return KErrArgument;

  1719 		}

  1654 		}

  1720 

  1655 

  1721 	Kern::RequestComplete(iClient,iRequestStatus[aReqNo & ~RDevUsbcScClient::ERequestCancel], KErrCancel);

  1656 	Kern::RequestComplete(iClient,iRequestStatus[aReqNo & ~RDevUsbcScClient::ERequestCancel], KErrCancel);

  1722 	return r;

  1657 	return r;

  1762 //

  1697 //

  1763 // Called from HandleMsg.

  1698 // Called from HandleMsg.

  1764 

  1699 

  1765 TInt DLddUsbcScChannel::DoControl(TInt aFunction, TAny* a1, TAny* a2)

  1700 TInt DLddUsbcScChannel::DoControl(TInt aFunction, TAny* a1, TAny* a2)

  1766 	{

  1701 	{

  1769 	TInt r = KErrNone;

  1704 	TInt r = KErrNone;

  1770 	TInt ep, param;

  1705 	TInt ep, param;

  1771 	TUsbcScEndpoint* pEndpoint;

  1706 	TUsbcScEndpoint* pEndpoint;

  1772 	TPtrC8 pZeroDesc(NULL, 0);

  1707 	TPtrC8 pZeroDesc(NULL, 0);

  1773 	TEndpointDescriptorInfo epInfo;

  1708 	TEndpointDescriptorInfo epInfo;

  1776 	TUsbcEndpointResource epRes;

  1711 	TUsbcEndpointResource epRes;

  1777 

  1712 

  1778 	switch (aFunction)

  1713 	switch (aFunction)

  1779 		{

  1714 		{

  1780 	case RDevUsbcScClient::EControlEndpointZeroRequestError:

  1715 	case RDevUsbcScClient::EControlEndpointZeroRequestError:

  1782 		r = KErrNone;

  1717 		r = KErrNone;

  1783 		if (iOwnsDeviceControl || (iValidInterface && iDeviceState == EUsbcDeviceStateConfigured))

  1718 		if (iOwnsDeviceControl || (iValidInterface && iDeviceState == EUsbcDeviceStateConfigured))

  1784 			{

  1719 			{

  1785 			iController->Ep0Stall(this);

  1720 			iController->Ep0Stall(this);

  1786 			}

  1721 			}

  1792 				r = KErrUsbInterfaceNotReady;

  1727 				r = KErrUsbInterfaceNotReady;

  1793 			}

  1728 			}

  1794 		break;

  1729 		break;

  1795 

  1730 

  1796 	case RDevUsbcScClient::EControlGetAlternateSetting:

  1731 	case RDevUsbcScClient::EControlGetAlternateSetting:

  1798 		if (iValidInterface && iDeviceState == EUsbcDeviceStateConfigured)

  1733 		if (iValidInterface && iDeviceState == EUsbcDeviceStateConfigured)

  1799 			{

  1734 			{

  1800 			r = iController->GetInterfaceNumber(this, param);

  1735 			r = iController->GetInterfaceNumber(this, param);

  1801 			if (r == KErrNone)

  1736 			if (r == KErrNone)

  1802 				{

  1737 				{

  1813 				r = KErrUsbInterfaceNotReady;

  1748 				r = KErrUsbInterfaceNotReady;

  1814 			}

  1749 			}

  1815 		break;

  1750 		break;

  1816 

  1751 

  1817 	case RDevUsbcScClient::EControlDeviceStatus:

  1752 	case RDevUsbcScClient::EControlDeviceStatus:

  1819 		param = iController->GetDeviceStatus();

  1754 		param = iController->GetDeviceStatus();

  1820 		r = Kern::ThreadRawWrite(iClient, a1, &param, sizeof(param), iClient);

  1755 		r = Kern::ThreadRawWrite(iClient, a1, &param, sizeof(param), iClient);

  1821 		if (r != KErrNone)

  1756 		if (r != KErrNone)

  1822 			PanicClientThread(r);

  1757 			PanicClientThread(r);

  1823 		break;

  1758 		break;

  1824 

  1759 

  1825 	case RDevUsbcScClient::EControlEndpointStatus:

  1760 	case RDevUsbcScClient::EControlEndpointStatus:

  1827 		if (iValidInterface && ValidEndpoint((TInt) a1))

  1762 		if (iValidInterface && ValidEndpoint((TInt) a1))

  1828 			{

  1763 			{

  1829 			pEndpoint = iEndpoint[(TInt)a1];

  1764 			pEndpoint = iEndpoint[(TInt)a1];

  1830 			if (pEndpoint == NULL)

  1765 			if (pEndpoint == NULL)

  1831 				r = KErrNotSupported;

  1766 				r = KErrNotSupported;

  1845 				r = KErrUsbInterfaceNotReady;

  1780 				r = KErrUsbInterfaceNotReady;

  1846 			}

  1781 			}

  1847 		break;

  1782 		break;

  1848 

  1783 

  1849 	case RDevUsbcScClient::EControlEndpointCaps:

  1784 	case RDevUsbcScClient::EControlEndpointCaps:

  1851 		r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient);

  1786 		r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient);

  1852 		if (r != KErrNone)

  1787 		if (r != KErrNone)

  1853 			PanicClientThread(r);

  1788 			PanicClientThread(r);

  1854 		iController->EndpointCaps(this, *((TDes8*) a1));

  1789 		iController->EndpointCaps(this, *((TDes8*) a1));

  1855 		break;

  1790 		break;

  1856 

  1791 

  1857 	case RDevUsbcScClient::EControlDeviceCaps:

  1792 	case RDevUsbcScClient::EControlDeviceCaps:

  1859 		r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient);

  1794 		r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient);

  1860 		if (r != KErrNone)

  1795 		if (r != KErrNone)

  1861 			PanicClientThread(r);

  1796 			PanicClientThread(r);

  1862 		iController->DeviceCaps(this, *((TDes8*) a1));

  1797 		iController->DeviceCaps(this, *((TDes8*) a1));

  1863 		break;

  1798 		break;

  1864 

  1799 

  1865 	case RDevUsbcScClient::EControlSendEp0StatusPacket:

  1800 	case RDevUsbcScClient::EControlSendEp0StatusPacket:

  1867 		iController->SendEp0StatusPacket(this);

  1802 		iController->SendEp0StatusPacket(this);

  1868 		break;

  1803 		break;

  1869 

  1804 

  1870 	case RDevUsbcScClient::EControlHaltEndpoint:

  1805 	case RDevUsbcScClient::EControlHaltEndpoint:

  1872 		if (iValidInterface && ValidEndpoint((TInt) a1))

  1807 		if (iValidInterface && ValidEndpoint((TInt) a1))

  1873 			{

  1808 			{

  1874 			r = iController->HaltEndpoint(this, iEndpoint[(TInt)a1]->RealEpNumber());