19 

    19 

    20 /**

    20 /**

    21  @file d_usbcsc.cpp

    21  @file d_usbcsc.cpp

    22  @internalTechnology

    22  @internalTechnology

    23 */

    23 */

    25 #include <drivers/usbcsc.h>

    24 #include <drivers/usbcsc.h>

    26 #include "platform.h"

    25 #include "platform.h"

    27 

    31 

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

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

    29 *   DUsbcScLogDevice                                                          *

    33 *   DUsbcScLogDevice                                                          *

    30 *                                                                             *

    34 *                                                                             *

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

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

    65 TInt DUsbcScLogDevice::Install()

    69 TInt DUsbcScLogDevice::Install()

    66 	{

    70 	{

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

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

    68 	if (!DUsbClientController::UsbcControllerPointer())

    72 	if (!DUsbClientController::UsbcControllerPointer())

    69 		{

    73 		{

    71 		return KErrGeneral;

    76 		return KErrGeneral;

    72 		}

    77 		}

    73 	return SetName(&KUsbScLddName);

    78 	return SetName(&KUsbScLddName);

    74 	}

    79 	}

    75 

    80 

   135 

   140 

   136 // This method requests closing the chunk.

   141 // This method requests closing the chunk.

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

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

   138 void TUsbcScChunkInfo::Close()

   143 void TUsbcScChunkInfo::Close()

   139 {

   144 {

   142 	if (Kern::ChunkClose(iChunk))

   146 	if (Kern::ChunkClose(iChunk))

   143         {

   147         {

   147         }

   151         }

   148 }

   152 }

   149 

   153 

   150 

   154 

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

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

   154 	TUint rleMask = ~pageMask;

   158 	TUint rleMask = ~pageMask;

   155 	TUint pageSize = rleMask+1;

   159 	TUint pageSize = rleMask+1;

   156 	TInt r;

   160 	TInt r;

   157 	TLinAddr physAddr;

   161 	TLinAddr physAddr;

   158 

   162 

   160 

   164 

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

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

   163 	if (r==KErrNone)

   168 	if (r==KErrNone)

   164 		{	

   169 		{	

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

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

   170 

   175 

   171 		if (r!=KErrNone)

   176 		if (r!=KErrNone)

   172 				Epoc::FreePhysicalRam(physAddr, aSize);

   177 				Epoc::FreePhysicalRam(physAddr, aSize);

   173 		else 

   178 		else 

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

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

   175 			TInt rle;

   180 			TInt rle;

   176 			TInt i=0;

   181 			TInt i=0;

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

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

   178 				{

   183 				{

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

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

   182 				}

   187 				}

   183 			}

   188 			}

   184 		}

   189 		}

   185 	else if (r==KErrNoMemory)

   190 	else if (r==KErrNoMemory)

   216 	}

   221 	}

   217 

   222 

   218 

   223 

   219 void TUsbcScChunkInfo::ChunkCleanup()

   224 void TUsbcScChunkInfo::ChunkCleanup()

   220 {

   225 {

   222 	TUint physAddr;

   228 	TUint physAddr;

   223 	TInt length;

   229 	TInt length;

   224 	TInt offset = 0;

   230 	TInt offset = 0;

   225 	

   231 	

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

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

   247 	ldd->Close(NULL);

   253 	ldd->Close(NULL);

   248 }

   254 }

   249 

   255 

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

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

   251 {

   257 {

   254 	aChunk = new TUsbcScChunkInfo(aLdd);

   260 	aChunk = new TUsbcScChunkInfo(aLdd);

   255 	if (aChunk==NULL)

   261 	if (aChunk==NULL)

   256 		{

   262 		{

   257 		return KErrNoMemory;

   263 		return KErrNoMemory;

   258 		}

   264 		}

   263 		delete aChunk;

   269 		delete aChunk;

   264 		aChunk=NULL;

   270 		aChunk=NULL;

   265 		return r;

   271 		return r;

   266 		}

   272 		}

   267 

   273 

   269 	return KErrNone;

   276 	return KErrNone;

   270 }

   277 }

   271 

   278 

   272 // End TUsbcScChunkInfo

   279 // End TUsbcScChunkInfo

   273 

   280 

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

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

   341 		{

   348 		{

   342 		iBufferStart->iHead= iHead;

   349 		iBufferStart->iHead= iHead;

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

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

   344 		iBufferStart->iBilTail=iHead;

   351 		iBufferStart->iBilTail=iHead;

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

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

   348 		}

   354 		}

   349 }

   355 }

   350 

   356 

   351 

   357 

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

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

   368 

   374 

   369 */

   375 */

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

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

   371 	{

   377 	{

   373 	

   379 	

   374 	iCallback=aRequestInfo;

   380 	iCallback=aRequestInfo;

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

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

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

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

   377 	iMode = aFlags;

   383 	iMode = aFlags;

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

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

   380 		{

   387 		{

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

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

   383 		// And Start next read.

   391 		// And Start next read.

   384 		iNeedsPacket=KEpIsStarting;

   392 		iNeedsPacket=KEpIsStarting;

   385 		}

   393 		}

   386 	}

   394 	}

   387 

   395 

   388 

   396 

   389 

   397 

   390 void TUsbcScBuffer::Destroy()

   398 void TUsbcScBuffer::Destroy()

   391 {

   399 {

   393 	Cancel(KErrCancel);

   402 	Cancel(KErrCancel);

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

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

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

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

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

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

   397 		}

   406 		}

   402 

   411 

   403 TInt TUsbcScBuffer::StartDataRead()

   412 TInt TUsbcScBuffer::StartDataRead()

   404 {

   413 {

   405 	if (!iMaxPacketSize)

   414 	if (!iMaxPacketSize)

   406 	{

   415 	{

   408 		return KErrNone;

   418 		return KErrNone;

   409 	}

   419 	}

   410 	if (iStatusList.iState!=ENotRunning) 

   420 	if (iStatusList.iState!=ENotRunning) 

   411 		{

   421 		{

   413 		return KErrNone;

   424 		return KErrNone;

   414 		}

   425 		}

   415 

   426 

   416 	TInt maxLength;

   427 	TInt maxLength;

   417 	TInt freeSpace;

   428 	TInt freeSpace;

   419 

   430 

   420 	// get next request

   431 	// get next request

   421 	TUsbcScStatusElement* nextJob = iStatusList.Next();

   432 	TUsbcScStatusElement* nextJob = iStatusList.Next();

   422 	if (nextJob == NULL)

   433 	if (nextJob == NULL)

   423 		{

   434 		{

   425 		if (iMode && KUsbScCoupledRead)

   437 		if (iMode && KUsbScCoupledRead)

   426 			return KErrEof;

   438 			return KErrEof;

   427 		iStatusList.iState=EReadingAhead;

   439 		iStatusList.iState=EReadingAhead;

   428 		}

   440 		}

   429 	else

   441 	else

   430 		iStatusList.iState=EInProgress;

   442 		iStatusList.iState=EInProgress;

   431 

   443 

   432 	TInt tail = iBufferStart->iTail;

   444 	TInt tail = iBufferStart->iTail;

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

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

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

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

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

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

   437 

   448 

   438 

   449 

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

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

   440 		{

   451 		{

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

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

   444 

   455 

   445 		if (freeSpace<iMinReadSize)

   456 		if (freeSpace<iMinReadSize)

   446 			{

   457 			{

   447 			iStatusList.iState=ENotRunning;

   458 			iStatusList.iState=ENotRunning;

   449 			return KErrOverflow; 				// Read STALL !! !! !!

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

   450 			}

   462 			}

   451 

   463 

   452 		if (freeSpace<maxLength)

   464 		if (freeSpace<maxLength)

   453 			maxLength = freeSpace;

   465 			maxLength = freeSpace;

   454 		}

   466 		}

   455 	if (maxLength> iMaxReadSize) 

   467 	if (maxLength> iMaxReadSize) 

   456 		maxLength =  iMaxReadSize;

   468 		maxLength =  iMaxReadSize;

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

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

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

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

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

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

   461 

   472 

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

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

   463 	// set up callback stucture

   474 	// set up callback stucture

   464 

   475 

   466 	TInt r;

   477 	TInt r;

   467 	// Go!!

   478 	// Go!!

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

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

   469 	if (r!=KErrNone)

   480 	if (r!=KErrNone)

   470 		{

   481 		{

   472 		iStatusList.Complete(r);

   483 		iStatusList.Complete(r);

   473 		}

   484 		}

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

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

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

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

   476 	return KErrNone;

   487 	return KErrNone;

   477 }

   488 }

   478 

   489 

   479 

   490 

   480 void TUsbcScBuffer::CompleteRead(TBool aStartNextRead)

   491 void TUsbcScBuffer::CompleteRead(TBool aStartNextRead)

   481 {

   492 {

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

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

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

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

   486 	const TInt packetCount = iCallback->iRxPackets;

   497 	const TInt packetCount = iCallback->iRxPackets;

   487  	iCallback->iRxPackets=0;

   498  	iCallback->iRxPackets=0;

   488 	TUint flags = 0;

   499 	TUint flags = 0;

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

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

   498 

   509 

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

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

   500 	{

   511 	{

   501 

   512 

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

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

   505 	TLinAddr dummy;

   516 	TLinAddr dummy;

   508 	// Find iNext

   518 	// Find iNext

   509 

   519 

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

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

   511 	TInt maxLength; 

   521 	TInt maxLength; 

   512 

   522 

   515 		{

   525 		{

   516 		// round up.

   526 		// round up.

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

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

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

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

   519 

   529 

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

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

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

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

   523 			{

   534 			{

   524 			next = iFirstPacket;

   535 			next = iFirstPacket;

   525 			continue;

   536 			continue;

   526 			}

   537 			}

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

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

   528 		if (maxLength<iMinReadSize) 

   539 		if (maxLength<iMinReadSize) 

   529 			{

   540 			{

   530 			next+=maxLength;

   541 			next+=maxLength;

   532 			continue;

   544 			continue;

   533 			}

   545 			}

   534 		}

   546 		}

   535 	while (EFalse);

   547 	while (EFalse);

   536 

   548 

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

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

   540 

   552 

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

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

   542 	

   554 	

   543 // Create Header

   555 // Create Header

   549 	header->iBytes=aByteCount;

   561 	header->iBytes=aByteCount;

   550 	header->iNext=next;

   562 	header->iNext=next;

   551 	header->iAltSettingSeq=iLdd->iAsSeq;

   563 	header->iAltSettingSeq=iLdd->iAsSeq;

   552 	header->iAltSetting=iLdd->iAlternateSetting;

   564 	header->iAltSetting=iLdd->iAlternateSetting;

   553 	header->iFlags=aFlags;

   565 	header->iFlags=aFlags;

   556 	iStatusList.iState=ENotRunning;

   568 	iStatusList.iState=ENotRunning;

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

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

   558 		{

   570 		{

   559 			iStalled=next;

   571 			iStalled=next;

   560 		}

   572 		}

   561 	else

   573 	else

   562 		{

   574 		{

   563 

   575 

   565 		TInt oldHead=iHead;

   577 		TInt oldHead=iHead;

   566 		iHead = next;

   578 		iHead = next;

   567 

   579 

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

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

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

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

   581 				}

   593 				}

   582 			}

   594 			}

   583 		else

   595 		else

   584 			{

   596 			{

   585 			iBufferStart->iHead = next;

   597 			iBufferStart->iHead = next;

   587 			}

   600 			}

   588 		// Complete userside

   601 		// Complete userside

   589 		iStatusList.Complete();

   602 		iStatusList.Complete();

   590 		}  

   603 		}  

   591 	}

   604 	}

   605 	// Add alt setting change packet.

   618 	// Add alt setting change packet.

   606 

   619 

   607 

   620 

   608 	if (StartDataRead() == KErrOverflow)

   621 	if (StartDataRead() == KErrOverflow)

   609 	{

   622 	{

   611 	}

   625 	}

   612 

   626 

   613 	iBufferStart->iHead = iHead;

   627 	iBufferStart->iHead = iHead;

   614 	}

   628 	}

   615 

   629 

   616 

   630 

   617 

   631 

   618 void TUsbcScBuffer::StartDataWrite()

   632 void TUsbcScBuffer::StartDataWrite()

   619 	{

   633 	{

   620 	

   634 	

   622 	TUsbcScStatusElement* nextJob = iStatusList.Next();

   637 	TUsbcScStatusElement* nextJob = iStatusList.Next();

   623 	TBool zlpReqd;

   638 	TBool zlpReqd;

   624 	TInt length;

   639 	TInt length;

   625 	TUint start;

   640 	TUint start;

   626 	TUint8* startAddr;

   641 	TUint8* startAddr;

   627 	TInt maxLength;

   642 	TInt maxLength;

   628 	TPhysAddr physAddr;

   643 	TPhysAddr physAddr;

   629 	TInt r;

   644 	TInt r;

   630 	if (!iMaxPacketSize)

   645 	if (!iMaxPacketSize)

   631 	{

   646 	{

   633 		return;

   648 		return;

   634 	}

   649 	}

   635 

   650 

   636 	if (nextJob == NULL)

   651 	if (nextJob == NULL)

   637 		{

   652 		{

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

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

   640 			{

   655 			{

   642 			// Start other read again.

   657 			// Start other read again.

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

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

   644 			}

   659 			}

   645 		}

   660 		}

   646 	else

   661 	else

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

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

   678 		iCallback->iZlpReqd = zlpReqd;

   693 		iCallback->iZlpReqd = zlpReqd;

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

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

   680 		if (r!=KErrNone)

   695 		if (r!=KErrNone)

   681 			{

   696 			{

   683 			iStatusList.Complete(r);

   699 			iStatusList.Complete(r);

   684 			}

   700 			}

   685 		}

   701 		}

   686 

   702 

   687 	}

   703 	}

   688 

   704 

   689 void TUsbcScBuffer::CompleteWrite()

   705 void TUsbcScBuffer::CompleteWrite()

   690 	{

   706 	{

   691 	TInt error = iCallback->iError;

   707 	TInt error = iCallback->iError;

   693 	iSent+= iCallback->iTxBytes;

   709 	iSent+= iCallback->iTxBytes;

   694 

   710 

   695 	// More to send?

   711 	// More to send?

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

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

   697 		{

   713 		{

   737 		}

   753 		}

   738 	}

   754 	}

   739 

   755 

   740 void TUsbcScBuffer::SendEp0StatusPacket(TInt aState)

   756 void TUsbcScBuffer::SendEp0StatusPacket(TInt aState)

   741 {

   757 {

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

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

   745 	// another after we have added out packet.  

   761 	// another after we have added out packet.  

   746 	Ep0CancelLddRead();

   762 	Ep0CancelLddRead();

   747 

   763 

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

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

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

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

   808 	}

   824 	}

   809 

   825 

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

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

   811 	{

   827 	{

   813 	if (iLength<iSize)

   830 	if (iLength<iSize)

   814 		{

   831 		{

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

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

   816 		e.iStatus = aStatus;

   833 		e.iStatus = aStatus;

   817 		e.iLength = aLength;

   834 		e.iLength = aLength;

   818 		e.iStart = aStart;

   835 		e.iStart = aStart;

   819 		e.iFlags = aFlags;

   836 		e.iFlags = aFlags;

   820 		iLength++;

   837 		iLength++;

   823 		return KErrNone;

   840 		return KErrNone;

   824 		}

   841 		}

   825 	else

   842 	else

   826 		return KErrInUse;

   843 		return KErrInUse;

   827 	}

   844 	}

   864 

   881 

   865 TInt TUsbcScStatusList::Complete(TInt aError)

   882 TInt TUsbcScStatusList::Complete(TInt aError)

   866 	{

   883 	{

   867 	if (iState==ENotRunning)

   884 	if (iState==ENotRunning)

   868 		{

   885 		{

   870 		}

   888 		}

   871  	else

   889  	else

   872 		{

   890 		{

   873 		iState=ENotRunning;

   891 		iState=ENotRunning;

   874 		if (iLength==0)

   892 		if (iLength==0)

   890 

   908 

   891 void TUsbcScStatusList::Complete()

   909 void TUsbcScStatusList::Complete()

   892 	{

   910 	{

   893 	if (iLength==0)

   911 	if (iLength==0)

   894 		return;

   912 		return;

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

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

   898 

   916 

   899 	iLength--;

   917 	iLength--;

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

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

   901 	}

   919 	}

   904 void TUsbcScStatusList::SetClient(DThread& aThread)

   920 void TUsbcScStatusList::SetClient(DThread& aThread)

   905 	{

   921 	{

   906 	iClient = &aThread;

   922 	iClient = &aThread;

   907 	}

   923 	}

   909 

   924 

   910 // End TUsbcScStatusList

   925 // End TUsbcScStatusList

   911 

   926 

   912 /*****************************************************************************\

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

   913 *   TRealizeInfo                                                              *

   928 *   TRealizeInfo                                                              *

   931 	iAlternateSettingList = aAlternateSettingList;

   946 	iAlternateSettingList = aAlternateSettingList;

   932 	iMaxEndpoints=0;

   947 	iMaxEndpoints=0;

   933 	iTotalSize   =0;

   948 	iTotalSize   =0;

   934 	iTotalBuffers=0;

   949 	iTotalBuffers=0;

   935 	iAltSettings =0;

   950 	iAltSettings =0;

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

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

   938 

   954 

   939 	if (iAlternateSettingList)

   955 	if (iAlternateSettingList)

   940 		{

   956 		{

   941 		TUsbcScAlternateSetting* alt = iAlternateSettingList->iHead;

   957 		TUsbcScAlternateSetting* alt = iAlternateSettingList->iHead;

   948 			alt = alt->iNext;

   964 			alt = alt->iNext;

   949 			};

   965 			};

   950 		}

   966 		}

   951 	

   967 	

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

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

   954 	TInt inout;

   971 	TInt inout;

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

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

   956 		{

   973 		{

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

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

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

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

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

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

   971 //

   988 //

   972 

   989 

   973 TInt TRealizeInfo::CopyAndSortEndpoints()

   990 TInt TRealizeInfo::CopyAndSortEndpoints()

   974 	{

   991 	{

   976 

   993 

   977 	TInt altSetting = 0;

   994 	TInt altSetting = 0;

   978 	TInt endpointOffs;

   995 	TInt endpointOffs;

   979 	TInt endpoint;

   996 	TInt endpoint;

   980 	TInt altEp;

   997 	TInt altEp;

   985 

  1002 

   986 	if (iAlternateSettingList)

  1003 	if (iAlternateSettingList)

   987 		{

  1004 		{

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

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

   989 			{		

  1006 			{		

   992 			iBufs[KUsbcScIn].iEps =0;

  1009 			iBufs[KUsbcScIn].iEps =0;

   993 			iBufs[KUsbcScOut].iEps =0;

  1010 			iBufs[KUsbcScOut].iEps =0;

   994 

  1011 

   995 			// For alt setting, iterate eps

  1012 			// For alt setting, iterate eps

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

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

   997 				{

  1014 				{

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

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

  1001 

  1017 

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

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

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

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

  1006 				if (inout==KUsbcScUnknown)

  1022 				if (inout==KUsbcScUnknown)

  1007 					{

  1023 					{

  1009 					return KErrArgument;

  1026 					return KErrArgument;

  1010 					}

  1027 					}

  1011 

  1028 

  1012 				bufsd = &(iBufs[inout]);

  1029 				bufsd = &(iBufs[inout]);

  1015 

  1031 

  1016 				// find and position ep, and insert.

  1032 				// find and position ep, and insert.

  1017 

  1033 

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

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

  1019 					{

  1035 					{

  1021 					endpointOffs = altSetting*iMaxEndpoints;

  1038 					endpointOffs = altSetting*iMaxEndpoints;

  1022 					bufsd->iEp[endpointOffs] = nextEp;

  1039 					bufsd->iEp[endpointOffs] = nextEp;

  1023 					}

  1040 					}

  1024 				else

  1041 				else

  1025 					{

  1042 					{

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

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

  1029 						{

  1046 						{

  1030 						endpointOffs = altSetting*iMaxEndpoints + endpoint;

  1047 						endpointOffs = altSetting*iMaxEndpoints + endpoint;

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

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

  1032 							{

  1049 							{

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

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

  1036 							}

  1052 							}

  1037 						else

  1053 						else

  1038 							{

  1054 							{

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

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

  1042 							placed = ETrue;

  1057 							placed = ETrue;

  1043 							break;

  1058 							break;

  1044 							}

  1059 							}

  1045 						} // end for endpoint

  1060 						} // end for endpoint

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

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

  1062 // required.

  1077 // required.

  1063 

  1078 

  1064 void TRealizeInfo::CalcBuffSizes()

  1079 void TRealizeInfo::CalcBuffSizes()

  1065 	{

  1080 	{

  1068 	TInt endpoint;

  1083 	TInt endpoint;

  1069 	TInt inout;

  1084 	TInt inout;

  1070 	TInt altSetting;

  1085 	TInt altSetting;

  1071 	TUsbcScEndpoint* nextEp;

  1086 	TUsbcScEndpoint* nextEp;

  1072 	TInt bufferSize;

  1087 	TInt bufferSize;

  1073 	TEndpointSortBufs* bufsd;

  1088 	TEndpointSortBufs* bufsd;

  1074 

  1089 

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

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

  1076 		{

  1091 		{

  1079 

  1093 

  1080 		bufsd = &(iBufs[inout]);

  1094 		bufsd = &(iBufs[inout]);

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

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

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

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

  1083 			{

  1097 			{

  1085 			TInt bufMaxSize=0;

  1099 			TInt bufMaxSize=0;

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

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

  1087 				{

  1101 				{

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

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

  1090 				if (nextEp!=NULL)

  1104 				if (nextEp!=NULL)

  1091 					{

  1105 					{

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

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

  1094 					if (bufferSize> bufMaxSize)

  1108 					if (bufferSize> bufMaxSize)

  1095 						 bufMaxSize = bufferSize;

  1109 						 bufMaxSize = bufferSize;

  1096 					}

  1110 					}

  1097 				} // for altsetting

  1111 				} // for altsetting

  1099 			bufsd->iSizes[endpoint] = bufMaxSize;

  1113 			bufsd->iSizes[endpoint] = bufMaxSize;

  1100 			if (bufMaxSize>0) 

  1114 			if (bufMaxSize>0) 

  1101 				{

  1115 				{

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

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

  1103 				iTotalBuffers++;

  1117 				iTotalBuffers++;

  1146 	iAltSettingsTbl->iEpRecordSize = sizeof(TUint);

  1160 	iAltSettingsTbl->iEpRecordSize = sizeof(TUint);

  1147 	iAltSettingsTbl->iNumOfAltSettings = iAltSettings;

  1161 	iAltSettingsTbl->iNumOfAltSettings = iAltSettings;

  1148 

  1162 

  1149 

  1163 

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

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

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

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

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

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

  1157 

  1169 

  1158 	TInt* noEpForAlt;

  1170 	TInt* noEpForAlt;

  1159 	TInt altSetting;

  1171 	TInt altSetting;

  1161 	if (iAlternateSettingList)

  1173 	if (iAlternateSettingList)

  1162 		{

  1174 		{

  1163 		alt = iAlternateSettingList->iHead;

  1175 		alt = iAlternateSettingList->iHead;

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

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

  1165 			{

  1177 			{

  1168 				iAltSettingsTbl->iAltTableOffset[altSetting] = tableOffset;

  1179 				iAltSettingsTbl->iAltTableOffset[altSetting] = tableOffset;

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

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

  1170 			 

  1181 			 

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

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

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

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

  1213 	  iChunkInfo(NULL),

  1224 	  iChunkInfo(NULL),

  1214 	  iNumBuffers(-1),

  1225 	  iNumBuffers(-1),

  1215 	  iBuffers(NULL),

  1226 	  iBuffers(NULL),

  1216 	  iEp0Endpoint(NULL)

  1227 	  iEp0Endpoint(NULL)

  1217 	{

  1228 	{

  1219 	iClient = &Kern::CurrentThread();

  1231 	iClient = &Kern::CurrentThread();

  1220 	iClient->Open();

  1232 	iClient->Open();

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

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

  1222 		{

  1234 		{

  1223 		iRequestStatus[i] = NULL;

  1235 		iRequestStatus[i] = NULL;

  1229 // Destructor

  1241 // Destructor

  1230 //

  1242 //

  1231 

  1243 

  1232 DLddUsbcScChannel::~DLddUsbcScChannel()

  1244 DLddUsbcScChannel::~DLddUsbcScChannel()

  1233 	{

  1245 	{

  1235 	if (iController)

  1247 	if (iController)

  1236 		{

  1248 		{

  1237 		iController->DeRegisterClient(this);

  1249 		iController->DeRegisterClient(this);

  1238 		iStatusCallbackInfo.Cancel();

  1250 		iStatusCallbackInfo.Cancel();

  1239 		iEndpointStatusCallbackInfo.Cancel();

  1251 		iEndpointStatusCallbackInfo.Cancel();

  1250 		if (iStatusFifo!=NULL)

  1262 		if (iStatusFifo!=NULL)

  1251 			{

  1263 			{

  1252 			delete iStatusFifo;

  1264 			delete iStatusFifo;

  1253 			}

  1265 			}

  1254 		}

  1266 		}

  1256 	if (iBuffers)

  1268 	if (iBuffers)

  1257 		{

  1269 		{

  1258 		TInt i;

  1270 		TInt i;

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

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

  1260 			{

  1272 			{

  1264 		}

  1276 		}

  1265 

  1277 

  1266 	if (iRealizeCalled)

  1278 	if (iRealizeCalled)

  1267 		{

  1279 		{

  1268 		// Close Chunk

  1280 		// Close Chunk

  1270 		iChunkInfo->Close();

  1282 		iChunkInfo->Close();

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

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

  1272 		iChunkInfo=NULL;

  1284 		iChunkInfo=NULL;

  1273 		}

  1285 		}

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

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

  1277 	}

  1289 	}

  1278 

  1290 

  1279 

  1291 

  1280 //

  1292 //

  1281 // DoCreate - Create channel

  1293 // DoCreate - Create channel

  1282 //

  1294 //

  1283 

  1295 

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

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

  1285 	{

  1297 	{

  1288 	if (!Kern::CurrentThreadHasCapability(ECapabilityCommDD,

  1301 	if (!Kern::CurrentThreadHasCapability(ECapabilityCommDD,

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

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

  1290 		{

  1303 		{

  1291 		return KErrPermissionDenied;

  1304 		return KErrPermissionDenied;

  1292 		}

  1305 		}

  1342 

  1355 

  1343 void DLddUsbcScChannel::HandleMsg(TMessageBase* aMsg)

  1356 void DLddUsbcScChannel::HandleMsg(TMessageBase* aMsg)

  1344 	{

  1357 	{

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

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

  1346 	TInt id = m.iValue;

  1359 	TInt id = m.iValue;

  1349 	if (id == (TInt) ECloseMsg)

  1362 	if (id == (TInt) ECloseMsg)

  1350 		{

  1363 		{

  1351 		iChannelClosing = ETrue;

  1364 		iChannelClosing = ETrue;

  1352 		m.Complete(KErrNone, EFalse);

  1365 		m.Complete(KErrNone, EFalse);

  1353 		return;

  1366 		return;

  1354 		}

  1367 		}

  1355 

  1368 

  1356 	TInt r;

  1369 	TInt r;

  1358 	if (aMsg->Client() != iClient)

  1370 	if (aMsg->Client() != iClient)

  1359 		{

  1371 		{

  1360 		m.Complete(KErrAccessDenied, ETrue);

  1372 		m.Complete(KErrAccessDenied, ETrue);

  1361 		return;

  1373 		return;

  1362 		}

  1374 		}

  1364 	if (id < 0)

  1375 	if (id < 0)

  1365 		{

  1376 		{

  1366 		// DoRequest

  1377 		// DoRequest

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

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

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

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

  1382 		}

  1393 		}

  1383 	}

  1394 	}

  1384 // end HandleMsg.

  1395 // end HandleMsg.

  1385 

  1396 

  1386 

  1397 

  1389 //

  1398 //

  1390 // DoRequest - Asynchronous requests

  1399 // DoRequest - Asynchronous requests

  1391 //

  1400 //

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

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

  1393 //

  1402 //

  1395 	{

  1404 	{

  1396 	TInt reqNo = aReqNo & RDevUsbcScClient::KFieldIdMask;

  1405 	TInt reqNo = aReqNo & RDevUsbcScClient::KFieldIdMask;

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

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

  1398 	TBool needsCompletion =EFalse;

  1407 	TBool needsCompletion =EFalse;

  1399 

  1408 

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

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

  1403 		(reqNo<RDevUsbcScClient::ERequestMaxRequests))

  1412 		(reqNo<RDevUsbcScClient::ERequestMaxRequests))

  1404 		{

  1413 		{

  1405 		if (iRequestStatus[reqNo])

  1414 		if (iRequestStatus[reqNo])

  1406 			{

  1415 			{

  1413 	switch (reqNo)

  1422 	switch (reqNo)

  1414 		{

  1423 		{

  1415 	case RDevUsbcScClient::ERequestWriteData:

  1424 	case RDevUsbcScClient::ERequestWriteData:

  1416 		{

  1425 		{

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

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

  1420 

  1434 

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

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

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

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

  1423 		break;

  1437 		break;

  1424 		}

  1438 		}

  1425 	case RDevUsbcScClient::ERequestReadDataNotify:

  1439 	case RDevUsbcScClient::ERequestReadDataNotify:

  1426 		{

  1440 		{

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

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

  1429 		} 

  1443 		} 

  1430 

  1444 

  1431 	case RDevUsbcScClient::ERequestAlternateDeviceStatusNotify:

  1445 	case RDevUsbcScClient::ERequestAlternateDeviceStatusNotify:

  1432 		{

  1446 		{

  1435 		iDeviceStatusNeeded = ETrue;

  1454 		iDeviceStatusNeeded = ETrue;

  1436 		iStatusChangePtr = a1;

  1455 		iStatusChangePtr = a1;

  1437 		needsCompletion = AlternateDeviceStateTestComplete();

  1456 		needsCompletion = AlternateDeviceStateTestComplete();

  1438 		break;

  1457 		break;

  1439 		}

  1458 		}

  1440 	case RDevUsbcScClient::ERequestReEnumerate:

  1459 	case RDevUsbcScClient::ERequestReEnumerate:

  1441 		{

  1460 		{

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

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

  1444 		r = iController->ReEnumerate();

  1463 		r = iController->ReEnumerate();

  1445 		break;

  1464 		break;

  1446 		}

  1465 		}

  1447 	case RDevUsbcScClient::ERequestEndpointStatusNotify:

  1466 	case RDevUsbcScClient::ERequestEndpointStatusNotify:

  1448 		{

  1467 		{

  1452 		iEndpointStatusChangePtr = a1;

  1475 		iEndpointStatusChangePtr = a1;

  1453 		break;

  1476 		break;

  1454 		}

  1477 		}

  1455 	case RDevUsbcScClient::ERequestOtgFeaturesNotify:

  1478 	case RDevUsbcScClient::ERequestOtgFeaturesNotify:

  1456 		{

  1479 		{

  1460 		iOtgFeatureChangePtr = a1;

  1487 		iOtgFeatureChangePtr = a1;

  1461 		break;

  1488 		break;

  1462 		}

  1489 		}

  1463     default:

  1490     default:

  1464 		r = KErrNotSupported;

  1491 		r = KErrNotSupported;

  1479 //

  1506 //

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

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

  1481 //

  1508 //

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

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

  1483 	{

  1510 	{

  1485 	TInt r = KErrNone;

  1513 	TInt r = KErrNone;

  1486 	// check range

  1514 	// check range

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

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

  1488 		{

  1516 		{

  1489 		if (aBufferNum!=KUsbcScEndpointZero)

  1517 		if (aBufferNum!=KUsbcScEndpointZero)

  1490 			{

  1518 			{

  1492 			return KErrArgument;

  1521 			return KErrArgument;

  1493 			}

  1522 			}

  1494 		else

  1523 		else

  1495 			{

  1524 			{

  1496 			aBufferNum = iEP0OutBuff;

  1525 			aBufferNum = iEP0OutBuff;

  1499 	else

  1528 	else

  1500 		{

  1529 		{

  1501 		// check direction

  1530 		// check direction

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

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

  1503 			{

  1532 			{

  1505 			return KErrNotSupported;

  1534 			return KErrNotSupported;

  1506 			}

  1535 			}

  1507 		if (!Configured())

  1536 		if (!Configured())

  1508 			return KErrUsbInterfaceNotReady;

  1537 			return KErrUsbInterfaceNotReady;

  1509 		}

  1538 		}

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

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

  1511 

  1540 

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

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

  1515 		r = KErrCompletion;

  1543 		r = KErrCompletion;

  1516 	else

  1544 	else

  1517 		if (iBuffers[aBufferNum].iStalled)

  1545 		if (iBuffers[aBufferNum].iStalled)

  1518 			{

  1546 			{

  1526 		{

  1554 		{

  1527 		iBuffers[aBufferNum].StartDataRead();

  1555 		iBuffers[aBufferNum].StartDataRead();

  1528 		}

  1556 		}

  1529 	else

  1557 	else

  1530 		{

  1558 		{

  1532 		}

  1560 		}

  1533 	return r;

  1561 	return r;

  1534 	}

  1562 	}

  1535 // end DoReadDataNotify.

  1563 // end DoReadDataNotify.

  1536 

  1564 

  1541 //

  1569 //

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

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

  1543 //

  1571 //

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

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

  1545 	{

  1573 	{

  1547 	if (!iUserKnowsAltSetting)

  1576 	if (!iUserKnowsAltSetting)

  1548 		return KErrEof;

  1577 		return KErrEof;

  1549 	// Check Buffer Number

  1578 	// Check Buffer Number

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

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

  1551 		{

  1580 		{

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

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

  1553 			{

  1582 			{

  1555 			return KErrArgument;

  1584 			return KErrArgument;

  1556 			}

  1585 			}

  1557 		else

  1586 		else

  1558 			{

  1587 			{

  1559 			aBufferNum = iEP0InBuff;

  1588 			aBufferNum = iEP0InBuff;

  1562 	else

  1591 	else

  1563 		{

  1592 		{

  1564 		// check direction

  1593 		// check direction

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

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

  1566 			{

  1595 			{

  1568 				return KErrArgument;

  1597 				return KErrArgument;

  1569 			}

  1598 			}

  1570 		}

  1599 		}

  1571 

  1600 

  1572 	TUsbcScBuffer& buf=iBuffers[aBufferNum];

  1601 	TUsbcScBuffer& buf=iBuffers[aBufferNum];

  1573 

  1602 

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

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

  1575 		{

  1604 		{

  1577 		return KErrArgument;

  1606 		return KErrArgument;

  1578 		}

  1607 		}

  1579 

  1608 

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

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

  1581 		return KErrUsbInterfaceNotReady;

  1610 		return KErrUsbInterfaceNotReady;

  1582 

  1611 

  1583 	if (aStart & ~buf.iAlignMask)

  1612 	if (aStart & ~buf.iAlignMask)

  1584 		{

  1613 		{

  1586 		return KErrArgument;

  1616 		return KErrArgument;

  1587 		}

  1617 		}

  1588 			

  1618 			

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

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

  1590 

  1620 

  1592 		{

  1622 		{

  1593 			iBuffers[aBufferNum].StartDataWrite();

  1623 			iBuffers[aBufferNum].StartDataWrite();

  1594 		}

  1624 		}

  1595 	else

  1625 	else

  1596 		{	

  1626 		{	

  1598 		}

  1628 		}

  1599 

  1629 

  1600 

  1630 

  1601 	return r;

  1631 	return r;

  1602 	}

  1632 	}

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

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

  1610 	{

  1640 	{

  1611 	TInt r = KErrNone;

  1641 	TInt r = KErrNone;

  1612 	TInt direction=KUsbcScOut;

  1642 	TInt direction=KUsbcScOut;

  1613 

  1643 

  1615 	switch (aReqNo)

  1646 	switch (aReqNo)

  1616 		{

  1647 		{

  1617 	case RDevUsbcScClient::ERequestCancel:

  1648 	case RDevUsbcScClient::ERequestCancel:

  1618 		TInt buffer;

  1649 		TInt buffer;

  1619 		TInt mask;

  1650 		TInt mask;

  1626 

  1657 

  1627 	// coverity[missing_break]

  1658 	// coverity[missing_break]

  1628 	case RDevUsbcScClient::ERequestWriteDataCancel:

  1659 	case RDevUsbcScClient::ERequestWriteDataCancel:

  1629 		direction = KUsbcScIn;

  1660 		direction = KUsbcScIn;

  1630 	case RDevUsbcScClient::ERequestReadDataNotifyCancel:

  1661 	case RDevUsbcScClient::ERequestReadDataNotifyCancel:

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

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

  1634 			{

  1664 			{

  1636 			iEp0Endpoint->AbortTransfer();

  1666 			iEp0Endpoint->AbortTransfer();

  1637 			if (direction==KUsbcScIn)

  1667 			if (direction==KUsbcScIn)

  1638 				aBuff=iEP0InBuff;

  1668 				aBuff=iEP0InBuff;

  1639 			else

  1669 			else

  1640 				aBuff=iEP0OutBuff;

  1670 				aBuff=iEP0OutBuff;

  1641 			} 

  1671 			} 

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

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

  1643 			{

  1673 			{

  1645 			return KErrArgument;

  1675 			return KErrArgument;

  1646 			}

  1676 			}

  1647 

  1677 

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

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

  1649 			{

  1679 			{

  1651 			return KErrArgument;

  1681 			return KErrArgument;

  1652 			}	

  1682 			}	

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

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

  1654 		iBuffers[aBuff].Cancel(KErrCancel);

  1684 		iBuffers[aBuff].Cancel(KErrCancel);

  1655 		

  1685 		

  1656 		return KErrNone;

  1686 		return KErrNone;

  1657 

  1687 

  1658 	case RDevUsbcScClient::ERequestAlternateDeviceStatusNotifyCancel:

  1688 	case RDevUsbcScClient::ERequestAlternateDeviceStatusNotifyCancel:

  1660 		iDeviceStatusNeeded = EFalse;

  1690 		iDeviceStatusNeeded = EFalse;

  1661 		iStatusFifo->FlushQueue();

  1691 		iStatusFifo->FlushQueue();

  1662 		if (iStatusChangePtr)

  1692 		if (iStatusChangePtr)

  1663 			{

  1693 			{

  1664 			TInt deviceState = iController->GetDeviceStatus();

  1694 			TInt deviceState = iController->GetDeviceStatus();

  1668 			iStatusChangePtr = NULL; 

  1698 			iStatusChangePtr = NULL; 

  1669 			}

  1699 			}

  1670 	break;

  1700 	break;

  1671 

  1701 

  1672 	case RDevUsbcScClient::ERequestReEnumerateCancel:

  1702 	case RDevUsbcScClient::ERequestReEnumerateCancel:

  1674 	break;

  1704 	break;

  1675 

  1705 

  1676 	case RDevUsbcScClient::ERequestEndpointStatusNotifyCancel:

  1706 	case RDevUsbcScClient::ERequestEndpointStatusNotifyCancel:

  1678 		CancelNotifyEndpointStatus();

  1708 		CancelNotifyEndpointStatus();

  1679 	break;

  1709 	break;

  1680 

  1710 

  1681  	case RDevUsbcScClient::ERequestOtgFeaturesNotifyCancel:

  1711  	case RDevUsbcScClient::ERequestOtgFeaturesNotifyCancel:

  1683 		CancelNotifyOtgFeatures();

  1713 		CancelNotifyOtgFeatures();

  1684 	break;

  1714 	break;

  1685 

  1715 

  1686 	default:

  1716 	default:

  1688 		return KErrArgument;

  1718 		return KErrArgument;

  1689 		}

  1719 		}

  1690 

  1720 

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

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

  1692 	return r;

  1722 	return r;

  1732 //

  1762 //

  1733 // Called from HandleMsg.

  1763 // Called from HandleMsg.

  1734 

  1764 

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

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

  1736 	{

  1766 	{

  1739 	TInt r = KErrNone;

  1769 	TInt r = KErrNone;

  1740 	TInt ep, param;

  1770 	TInt ep, param;

  1741 	TUsbcScEndpoint* pEndpoint;

  1771 	TUsbcScEndpoint* pEndpoint;

  1742 	TPtrC8 pZeroDesc(NULL, 0);

  1772 	TPtrC8 pZeroDesc(NULL, 0);

  1743 	TEndpointDescriptorInfo epInfo;

  1773 	TEndpointDescriptorInfo epInfo;

  1746 	TUsbcEndpointResource epRes;

  1776 	TUsbcEndpointResource epRes;

  1747 

  1777 

  1748 	switch (aFunction)

  1778 	switch (aFunction)

  1749 		{

  1779 		{

  1750 	case RDevUsbcScClient::EControlEndpointZeroRequestError:

  1780 	case RDevUsbcScClient::EControlEndpointZeroRequestError:

  1752 		r = KErrNone;

  1782 		r = KErrNone;

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

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

  1754 			{

  1784 			{

  1755 			iController->Ep0Stall(this);

  1785 			iController->Ep0Stall(this);

  1756 			}

  1786 			}

  1762 				r = KErrUsbInterfaceNotReady;

  1792 				r = KErrUsbInterfaceNotReady;

  1763 			}

  1793 			}

  1764 		break;

  1794 		break;

  1765 

  1795 

  1766 	case RDevUsbcScClient::EControlGetAlternateSetting:

  1796 	case RDevUsbcScClient::EControlGetAlternateSetting:

  1768 		if (iValidInterface && iDeviceState == EUsbcDeviceStateConfigured)

  1798 		if (iValidInterface && iDeviceState == EUsbcDeviceStateConfigured)

  1769 			{

  1799 			{

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

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

  1771 			if (r == KErrNone)

  1801 			if (r == KErrNone)

  1772 				{

  1802 				{

  1783 				r = KErrUsbInterfaceNotReady;

  1813 				r = KErrUsbInterfaceNotReady;

  1784 			}

  1814 			}

  1785 		break;

  1815 		break;

  1786 

  1816 

  1787 	case RDevUsbcScClient::EControlDeviceStatus:

  1817 	case RDevUsbcScClient::EControlDeviceStatus:

  1789 		param = iController->GetDeviceStatus();

  1819 		param = iController->GetDeviceStatus();

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

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

  1791 		if (r != KErrNone)

  1821 		if (r != KErrNone)

  1792 			PanicClientThread(r);

  1822 			PanicClientThread(r);

  1793 		break;

  1823 		break;

  1794 

  1824 

  1795 	case RDevUsbcScClient::EControlEndpointStatus:

  1825 	case RDevUsbcScClient::EControlEndpointStatus:

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

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

  1798 			{

  1828 			{

  1799 			pEndpoint = iEndpoint[(TInt)a1];

  1829 			pEndpoint = iEndpoint[(TInt)a1];

  1800 			if (pEndpoint == NULL)

  1830 			if (pEndpoint == NULL)

  1801 				r = KErrNotSupported;

  1831 				r = KErrNotSupported;

  1815 				r = KErrUsbInterfaceNotReady;

  1845 				r = KErrUsbInterfaceNotReady;

  1816 			}

  1846 			}

  1817 		break;

  1847 		break;

  1818 

  1848 

  1819 	case RDevUsbcScClient::EControlEndpointCaps:

  1849 	case RDevUsbcScClient::EControlEndpointCaps:

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

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

  1822 		if (r != KErrNone)

  1852 		if (r != KErrNone)

  1823 			PanicClientThread(r);

  1853 			PanicClientThread(r);

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

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

  1825 		break;

  1855 		break;

  1826 

  1856 

  1827 	case RDevUsbcScClient::EControlDeviceCaps:

  1857 	case RDevUsbcScClient::EControlDeviceCaps:

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

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

  1830 		if (r != KErrNone)

  1860 		if (r != KErrNone)

  1831 			PanicClientThread(r);

  1861 			PanicClientThread(r);

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

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

  1833 		break;

  1863 		break;

  1834 

  1864 

  1835 	case RDevUsbcScClient::EControlSendEp0StatusPacket:

  1865 	case RDevUsbcScClient::EControlSendEp0StatusPacket:

  1837 		iController->SendEp0StatusPacket(this);

  1867 		iController->SendEp0StatusPacket(this);

  1838 		break;

  1868 		break;

  1839 

  1869 

  1840 	case RDevUsbcScClient::EControlHaltEndpoint:

  1870 	case RDevUsbcScClient::EControlHaltEndpoint:

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

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

  1843 			{

  1873 			{

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

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

  1845 			}

  1875 			}

  1846 		else

  1876 		else

  1851 				r = KErrUsbInterfaceNotReady;

  1881 				r = KErrUsbInterfaceNotReady;

  1852 			}

  1882 			}

  1853 		break;

  1883 		break;

  1854 

  1884 

  1855 	case RDevUsbcScClient::EControlClearHaltEndpoint:

  1885 	case RDevUsbcScClient::EControlClearHaltEndpoint:

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

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

  1858 			{

  1888 			{

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

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

  1860 			}

  1890 			}

  1861 		else

  1891 		else

  1866 				r = KErrUsbInterfaceNotReady;

  1896 				r = KErrUsbInterfaceNotReady;

  1867 			}

  1897 			}

  1868 		break;

  1898 		break;

  1869 

  1899 

  1870 	case RDevUsbcScClient::EControlDumpRegisters:

  1900 	case RDevUsbcScClient::EControlDumpRegisters:

  1872 		iController->DumpRegisters();

  1902 		iController->DumpRegisters();

  1873 		break;

  1903 		break;

  1874 

  1904 

  1875 	case RDevUsbcScClient::EControlReleaseDeviceControl:

  1905 	case RDevUsbcScClient::EControlReleaseDeviceControl:

  1877 		iController->ReleaseDeviceControl(this);

  1907 		iController->ReleaseDeviceControl(this);

  1878 		iOwnsDeviceControl = EFalse;

  1908 		iOwnsDeviceControl = EFalse;

  1879 		break;

  1909 		break;

  1880 

  1910 

  1881 	case RDevUsbcScClient::EControlEndpointZeroMaxPacketSizes:

  1911 	case RDevUsbcScClient::EControlEndpointZeroMaxPacketSizes:

  1883 		r = iController->EndpointZeroMaxPacketSizes();

  1913 		r = iController->EndpointZeroMaxPacketSizes();

  1884 		break;

  1914 		break;

  1885 

  1915 

  1886 	case RDevUsbcScClient::EControlSetEndpointZeroMaxPacketSize:

  1916 	case RDevUsbcScClient::EControlSetEndpointZeroMaxPacketSize:

  1888 		r = iController->SetEndpointZeroMaxPacketSize(reinterpret_cast<TInt>(a1));

  1918 		r = iController->SetEndpointZeroMaxPacketSize(reinterpret_cast<TInt>(a1));

  1889 		break;

  1919 		break;