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 */

    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 

    96 

   101 

    97 void DfcChunkCleanup(TAny*);

   102 void DfcChunkCleanup(TAny*);

    98 

   103 

    99 TUsbcScChunkInfo::TUsbcScChunkInfo(DLogicalDevice* aLdd)

   104 TUsbcScChunkInfo::TUsbcScChunkInfo(DLogicalDevice* aLdd)

   100 	: 	iChunk(NULL),

   105 	: 	iChunk(NULL),

   102 		iChunkMem(NULL),

   106 		iChunkMem(NULL),

   103 		iLdd(aLdd)

   107 		iLdd(aLdd)

   104 	{

   108 	{

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

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

   106 	}

   110 	}

   119 		TChunkCreateInfo chunkInfo;

   123 		TChunkCreateInfo chunkInfo;

   120 		chunkInfo.iType = TChunkCreateInfo::ESharedKernelMultiple;

   124 		chunkInfo.iType = TChunkCreateInfo::ESharedKernelMultiple;

   121 		chunkInfo.iMaxSize = aTotalSize;

   125 		chunkInfo.iMaxSize = aTotalSize;

   122 		chunkInfo.iMapAttr = EMapAttrCachedMax;

   126 		chunkInfo.iMapAttr = EMapAttrCachedMax;

   123 		chunkInfo.iOwnsMemory = EFalse;

   127 		chunkInfo.iOwnsMemory = EFalse;

   125 

   129 

   126 		TLinAddr chunkMem;

   130 		TLinAddr chunkMem;

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

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

   128 		iChunkMem = (TInt8*) chunkMem;

   132 		iChunkMem = (TInt8*) chunkMem;

   129 		if (r==KErrNone)

   133 		if (r==KErrNone)

   136 

   140 

   137 // This method requests closing the chunk.

   141 // This method requests closing the chunk.

   138 // 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.

   139 void TUsbcScChunkInfo::Close()

   143 void TUsbcScChunkInfo::Close()

   140 {

   144 {

   142 }

   152 }

   143 

   153 

   144 

   154 

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

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

   146 	{

   156 	{

   148 	TUint rleMask = ~pageMask;

   158 	TUint rleMask = ~pageMask;

   149 	TUint pageSize = rleMask+1;

   159 	TUint pageSize = rleMask+1;

   150 	TInt r;

   160 	TInt r;

   151 	TLinAddr physAddr;

   161 	TLinAddr physAddr;

   152 

   162 

   154 

   164 

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

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

   157 	if (r==KErrNone)

   168 	if (r==KErrNone)

   158 		{	

   169 		{	

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

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

   164 

   175 

   165 		if (r!=KErrNone)

   176 		if (r!=KErrNone)

   166 				Epoc::FreePhysicalRam(physAddr, aSize);

   177 				Epoc::FreePhysicalRam(physAddr, aSize);

   167 		else 

   178 		else 

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

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

   169 			TInt rle;

   180 			TInt rle;

   170 			TInt i=0;

   181 			TInt i=0;

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

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

   172 				{

   183 				{

   175 				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);

   176 				}

   187 				}

   177 			}

   188 			}

   178 		}

   189 		}

   179 	else if (r==KErrNoMemory)

   190 	else if (r==KErrNoMemory)

   210 	}

   221 	}

   211 

   222 

   212 

   223 

   213 void TUsbcScChunkInfo::ChunkCleanup()

   224 void TUsbcScChunkInfo::ChunkCleanup()

   214 {

   225 {

   216 	TUint physAddr;

   228 	TUint physAddr;

   217 	TInt length;

   229 	TInt length;

   218 	TInt offset = 0;

   230 	TInt offset = 0;

   219 	

   231 	

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

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

   241 	ldd->Close(NULL);

   253 	ldd->Close(NULL);

   242 }

   254 }

   243 

   255 

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

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

   245 {

   257 {

   248 	aChunk = new TUsbcScChunkInfo(aLdd);

   260 	aChunk = new TUsbcScChunkInfo(aLdd);

   249 	if (aChunk==NULL)

   261 	if (aChunk==NULL)

   250 		{

   262 		{

   251 		return KErrNoMemory;

   263 		return KErrNoMemory;

   252 		}

   264 		}

   257 		delete aChunk;

   269 		delete aChunk;

   258 		aChunk=NULL;

   270 		aChunk=NULL;

   259 		return r;

   271 		return r;

   260 		}

   272 		}

   261 

   273 

   263 	return KErrNone;

   276 	return KErrNone;

   264 }

   277 }

   265 

   278 

   266 // End TUsbcScChunkInfo

   279 // End TUsbcScChunkInfo

   267 

   280 

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

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

   335 		{

   348 		{

   336 		iBufferStart->iHead= iHead;

   349 		iBufferStart->iHead= iHead;

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

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

   338 		iBufferStart->iBilTail=iHead;

   351 		iBufferStart->iBilTail=iHead;

   341 		// 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)

   342 		}

   354 		}

   343 }

   355 }

   344 

   369 

   345 /*

   370 /*

   346 TUsbcScBuffer::StartEndpoint

   371 TUsbcScBuffer::StartEndpoint

   347 

   372 

   348 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.

   349 

   374 

   350 */

   375 */

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

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

   352 	{

   377 	{

   354 	

   379 	

   355 	iCallback=aRequestInfo;

   380 	iCallback=aRequestInfo;

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

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

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

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

   358 	iMode = aFlags;

   383 	iMode = aFlags;

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

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

   361 		{

   387 		{

   363 		// 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)

   364 		// And Start next read.

   391 		// And Start next read.

   365 		iNeedsPacket=KEpIsStarting;

   392 		iNeedsPacket=KEpIsStarting;

   366 		}

   393 		}

   367 	}

   394 	}

   368 

   395 

   369 

   396 

   370 

   397 

   371 void TUsbcScBuffer::Destroy()

   398 void TUsbcScBuffer::Destroy()

   372 {

   399 {

   374 	Cancel(KErrCancel);

   402 	Cancel(KErrCancel);

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

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

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

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

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

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

   378 		}

   406 		}

   383 

   411 

   384 TInt TUsbcScBuffer::StartDataRead()

   412 TInt TUsbcScBuffer::StartDataRead()

   385 {

   413 {

   386 	if (!iMaxPacketSize)

   414 	if (!iMaxPacketSize)

   387 	{

   415 	{

   389 		return KErrNone;

   418 		return KErrNone;

   390 	}

   419 	}

   391 	if (iStatusList.iState!=ENotRunning) 

   420 	if (iStatusList.iState!=ENotRunning) 

   392 		{

   421 		{

   394 		return KErrNone;

   424 		return KErrNone;

   395 		}

   425 		}

   396 

   426 

   397 	TInt maxLength;

   427 	TInt maxLength;

   398 	TInt freeSpace;

   428 	TInt freeSpace;

   400 

   430 

   401 	// get next request

   431 	// get next request

   402 	TUsbcScStatusElement* nextJob = iStatusList.Next();

   432 	TUsbcScStatusElement* nextJob = iStatusList.Next();

   403 	if (nextJob == NULL)

   433 	if (nextJob == NULL)

   404 		{

   434 		{

   406 		if (iMode && KUsbScCoupledRead)

   437 		if (iMode && KUsbScCoupledRead)

   407 			return KErrEof;

   438 			return KErrEof;

   408 		iStatusList.iState=EReadingAhead;

   439 		iStatusList.iState=EReadingAhead;

   409 		}

   440 		}

   410 	else

   441 	else

   411 		iStatusList.iState=EInProgress;

   442 		iStatusList.iState=EInProgress;

   412 

   443 

   413 	TInt tail = iBufferStart->iTail;

   444 	TInt tail = iBufferStart->iTail;

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

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

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

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

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

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

   418 

   448 

   419 

   449 

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

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

   421 		{

   451 		{

   424 		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.

   425 

   455 

   426 		if (freeSpace<iMinReadSize)

   456 		if (freeSpace<iMinReadSize)

   427 			{

   457 			{

   428 			iStatusList.iState=ENotRunning;

   458 			iStatusList.iState=ENotRunning;

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

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

   431 			}

   462 			}

   432 

   463 

   433 		if (freeSpace<maxLength)

   464 		if (freeSpace<maxLength)

   434 			maxLength = freeSpace;

   465 			maxLength = freeSpace;

   435 		}

   466 		}

   436 	if (maxLength> iMaxReadSize) 

   467 	if (maxLength> iMaxReadSize) 

   437 		maxLength =  iMaxReadSize;

   468 		maxLength =  iMaxReadSize;

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

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

   439 	// 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.

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

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

   442 

   472 

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

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

   444 	// set up callback stucture

   474 	// set up callback stucture

   445 

   475 

   447 	TInt r;

   477 	TInt r;

   448 	// Go!!

   478 	// Go!!

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

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

   450 	if (r!=KErrNone)

   480 	if (r!=KErrNone)

   451 		{

   481 		{

   453 		iStatusList.Complete(r);

   483 		iStatusList.Complete(r);

   454 		}

   484 		}

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

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

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

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

   457 	return KErrNone;

   487 	return KErrNone;

   458 }

   488 }

   459 

   489 

   460 

   490 

   461 void TUsbcScBuffer::CompleteRead(TBool aStartNextRead)

   491 void TUsbcScBuffer::CompleteRead(TBool aStartNextRead)

   462 {

   492 {

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

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

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

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

   467 	const TInt packetCount = iCallback->iRxPackets;

   497 	const TInt packetCount = iCallback->iRxPackets;

   468  	iCallback->iRxPackets=0;

   498  	iCallback->iRxPackets=0;

   469 	TUint flags = 0;

   499 	TUint flags = 0;

   478 // 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.

   479 

   509 

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

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

   481 	{

   511 	{

   482 

   512 

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

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

   486 	TLinAddr dummy;

   516 	TLinAddr dummy;

   489 	// Find iNext

   518 	// Find iNext

   490 

   519 

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

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

   492 	TInt maxLength; 

   521 	TInt maxLength; 

   493 

   522 

   496 		{

   525 		{

   497 		// round up.

   526 		// round up.

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

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

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

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

   500 

   529 

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

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

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

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

   504 			{

   534 			{

   505 			next = iFirstPacket;

   535 			next = iFirstPacket;

   506 			continue;

   536 			continue;

   507 			}

   537 			}

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

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

   509 		if (maxLength<iMinReadSize) 

   539 		if (maxLength<iMinReadSize) 

   510 			{

   540 			{

   511 			next+=maxLength;

   541 			next+=maxLength;

   513 			continue;

   544 			continue;

   514 			}

   545 			}

   515 		}

   546 		}

   516 	while (EFalse);

   547 	while (EFalse);

   517 

   548 

   520 	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.

   521 

   552 

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

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

   523 	

   554 	

   524 // Create Header

   555 // Create Header

   530 	header->iBytes=aByteCount;

   561 	header->iBytes=aByteCount;

   531 	header->iNext=next;

   562 	header->iNext=next;

   532 	header->iAltSettingSeq=iLdd->iAsSeq;

   563 	header->iAltSettingSeq=iLdd->iAsSeq;

   533 	header->iAltSetting=iLdd->iAlternateSetting;

   564 	header->iAltSetting=iLdd->iAlternateSetting;

   534 	header->iFlags=aFlags;

   565 	header->iFlags=aFlags;

   537 	iStatusList.iState=ENotRunning;

   568 	iStatusList.iState=ENotRunning;

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

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

   539 		{

   570 		{

   540 			iStalled=next;

   571 			iStalled=next;

   541 		}

   572 		}

   542 	else

   573 	else

   543 		{

   574 		{

   544 

   575 

   546 		TInt oldHead=iHead;

   577 		TInt oldHead=iHead;

   547 		iHead = next;

   578 		iHead = next;

   548 

   579 

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

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

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

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

   562 				}

   593 				}

   563 			}

   594 			}

   564 		else

   595 		else

   565 			{

   596 			{

   566 			iBufferStart->iHead = next;

   597 			iBufferStart->iHead = next;

   568 			}

   600 			}

   569 		// Complete userside

   601 		// Complete userside

   570 		iStatusList.Complete();

   602 		iStatusList.Complete();

   571 		}  

   603 		}  

   572 	}

   604 	}

   586 	// Add alt setting change packet.

   618 	// Add alt setting change packet.

   587 

   619 

   588 

   620 

   589 	if (StartDataRead() == KErrOverflow)

   621 	if (StartDataRead() == KErrOverflow)

   590 	{

   622 	{

   592 	}

   625 	}

   593 

   626 

   594 	iBufferStart->iHead = iHead;

   627 	iBufferStart->iHead = iHead;

   595 	}

   628 	}

   596 

   629 

   597 

   630 

   598 

   631 

   599 void TUsbcScBuffer::StartDataWrite()

   632 void TUsbcScBuffer::StartDataWrite()

   600 	{

   633 	{

   601 	

   634 	

   603 	TUsbcScStatusElement* nextJob = iStatusList.Next();

   637 	TUsbcScStatusElement* nextJob = iStatusList.Next();

   604 	TBool zlpReqd;

   638 	TBool zlpReqd;

   605 	TInt length;

   639 	TInt length;

   606 	TUint start;

   640 	TUint start;

   607 	TUint8* startAddr;

   641 	TUint8* startAddr;

   608 	TInt maxLength;

   642 	TInt maxLength;

   609 	TPhysAddr physAddr;

   643 	TPhysAddr physAddr;

   610 	TInt r;

   644 	TInt r;

   611 	if (!iMaxPacketSize)

   645 	if (!iMaxPacketSize)

   612 	{

   646 	{

   614 		return;

   648 		return;

   615 	}

   649 	}

   616 

   650 

   617 	if (nextJob == NULL)

   651 	if (nextJob == NULL)

   618 		{

   652 		{

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

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

   621 			{

   655 			{

   623 			// Start other read again.

   657 			// Start other read again.

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

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

   625 			}

   659 			}

   626 		}

   660 		}

   627 	else

   661 	else

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

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

   659 		iCallback->iZlpReqd = zlpReqd;

   693 		iCallback->iZlpReqd = zlpReqd;

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

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

   661 		if (r!=KErrNone)

   695 		if (r!=KErrNone)

   662 			{

   696 			{

   664 			iStatusList.Complete(r);

   699 			iStatusList.Complete(r);

   665 			}

   700 			}

   666 		}

   701 		}

   667 

   702 

   668 	}

   703 	}

   669 

   704 

   670 void TUsbcScBuffer::CompleteWrite()

   705 void TUsbcScBuffer::CompleteWrite()

   671 	{

   706 	{

   672 	TInt error = iCallback->iError;

   707 	TInt error = iCallback->iError;

   674 	iSent+= iCallback->iTxBytes;

   709 	iSent+= iCallback->iTxBytes;

   675 

   710 

   676 	// More to send?

   711 	// More to send?

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

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

   678 		{

   713 		{

   718 		}

   753 		}

   719 	}

   754 	}

   720 

   755 

   721 void TUsbcScBuffer::SendEp0StatusPacket(TInt aState)

   756 void TUsbcScBuffer::SendEp0StatusPacket(TInt aState)

   722 {

   757 {

   725 	// 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

   726 	// another after we have added out packet.  

   761 	// another after we have added out packet.  

   727 	Ep0CancelLddRead();

   762 	Ep0CancelLddRead();

   728 

   763 

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

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

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

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

   789 	}

   824 	}

   790 

   825 

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

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

   792 	{

   827 	{

   794 	if (iLength<iSize)

   830 	if (iLength<iSize)

   795 		{

   831 		{

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

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

   797 		e.iStatus = aStatus;

   833 		e.iStatus = aStatus;

   798 		e.iLength = aLength;

   834 		e.iLength = aLength;

   799 		e.iStart = aStart;

   835 		e.iStart = aStart;

   800 		e.iFlags = aFlags;

   836 		e.iFlags = aFlags;

   801 		iLength++;

   837 		iLength++;

   804 		return KErrNone;

   840 		return KErrNone;

   805 		}

   841 		}

   806 	else

   842 	else

   807 		return KErrInUse;

   843 		return KErrInUse;

   808 	}

   844 	}

   845 

   881 

   846 TInt TUsbcScStatusList::Complete(TInt aError)

   882 TInt TUsbcScStatusList::Complete(TInt aError)

   847 	{

   883 	{

   848 	if (iState==ENotRunning)

   884 	if (iState==ENotRunning)

   849 		{

   885 		{

   851 		}

   888 		}

   852  	else

   889  	else

   853 		{

   890 		{

   854 		iState=ENotRunning;

   891 		iState=ENotRunning;

   855 		if (iLength==0)

   892 		if (iLength==0)

   871 

   908 

   872 void TUsbcScStatusList::Complete()

   909 void TUsbcScStatusList::Complete()

   873 	{

   910 	{

   874 	if (iLength==0)

   911 	if (iLength==0)

   875 		return;

   912 		return;

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

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

   879 

   916 

   880 	iLength--;

   917 	iLength--;

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

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

   882 	}

   923 	}

   883 

   924 

   884 // End TUsbcScStatusList

   925 // End TUsbcScStatusList

   885 

   926 

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

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

   905 	iAlternateSettingList = aAlternateSettingList;

   946 	iAlternateSettingList = aAlternateSettingList;

   906 	iMaxEndpoints=0;

   947 	iMaxEndpoints=0;

   907 	iTotalSize   =0;

   948 	iTotalSize   =0;

   908 	iTotalBuffers=0;

   949 	iTotalBuffers=0;

   909 	iAltSettings =0;

   950 	iAltSettings =0;

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

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

   912 

   954 

   913 	if (iAlternateSettingList)

   955 	if (iAlternateSettingList)

   914 		{

   956 		{

   915 		TUsbcScAlternateSetting* alt = iAlternateSettingList->iHead;

   957 		TUsbcScAlternateSetting* alt = iAlternateSettingList->iHead;

   922 			alt = alt->iNext;

   964 			alt = alt->iNext;

   923 			};

   965 			};

   924 		}

   966 		}

   925 	

   967 	

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

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

   928 	TInt inout;

   971 	TInt inout;

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

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

   930 		{

   973 		{

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

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

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

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

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

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

   945 //

   988 //

   946 

   989 

   947 TInt TRealizeInfo::CopyAndSortEndpoints()

   990 TInt TRealizeInfo::CopyAndSortEndpoints()

   948 	{

   991 	{

   950 

   993 

   951 	TInt altSetting = 0;

   994 	TInt altSetting = 0;

   952 	TInt endpointOffs;

   995 	TInt endpointOffs;

   953 	TInt endpoint;

   996 	TInt endpoint;

   954 	TInt altEp;

   997 	TInt altEp;

   959 

  1002 

   960 	if (iAlternateSettingList)

  1003 	if (iAlternateSettingList)

   961 		{

  1004 		{

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

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

   963 			{		

  1006 			{		

   966 			iBufs[KUsbcScIn].iEps =0;

  1009 			iBufs[KUsbcScIn].iEps =0;

   967 			iBufs[KUsbcScOut].iEps =0;

  1010 			iBufs[KUsbcScOut].iEps =0;

   968 

  1011 

   969 			// For alt setting, iterate eps

  1012 			// For alt setting, iterate eps

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

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

   971 				{

  1014 				{

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

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

   975 

  1017 

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

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

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

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

   980 				if (inout==KUsbcScUnknown)

  1022 				if (inout==KUsbcScUnknown)

   981 					{

  1023 					{

   983 					return KErrArgument;

  1026 					return KErrArgument;

   984 					}

  1027 					}

   985 

  1028 

   986 				bufsd = &(iBufs[inout]);

  1029 				bufsd = &(iBufs[inout]);

   989 

  1031 

   990 				// find and position ep, and insert.

  1032 				// find and position ep, and insert.

   991 

  1033 

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

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

   993 					{

  1035 					{

   995 					endpointOffs = altSetting*iMaxEndpoints;

  1038 					endpointOffs = altSetting*iMaxEndpoints;

   996 					bufsd->iEp[endpointOffs] = nextEp;

  1039 					bufsd->iEp[endpointOffs] = nextEp;

   997 					}

  1040 					}

   998 				else

  1041 				else

   999 					{

  1042 					{

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

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

  1003 						{

  1046 						{

  1004 						endpointOffs = altSetting*iMaxEndpoints + endpoint;

  1047 						endpointOffs = altSetting*iMaxEndpoints + endpoint;

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

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

  1006 							{

  1049 							{

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

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

  1010 							}

  1052 							}

  1011 						else

  1053 						else

  1012 							{

  1054 							{

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

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

  1016 							placed = ETrue;

  1057 							placed = ETrue;

  1017 							break;

  1058 							break;

  1018 							}

  1059 							}

  1019 						} // end for endpoint

  1060 						} // end for endpoint

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

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

  1036 // required.

  1077 // required.

  1037 

  1078 

  1038 void TRealizeInfo::CalcBuffSizes()

  1079 void TRealizeInfo::CalcBuffSizes()

  1039 	{

  1080 	{

  1042 	TInt endpoint;

  1083 	TInt endpoint;

  1043 	TInt inout;

  1084 	TInt inout;

  1044 	TInt altSetting;

  1085 	TInt altSetting;

  1045 	TUsbcScEndpoint* nextEp;

  1086 	TUsbcScEndpoint* nextEp;

  1046 	TInt bufferSize;

  1087 	TInt bufferSize;

  1047 	TEndpointSortBufs* bufsd;

  1088 	TEndpointSortBufs* bufsd;

  1048 

  1089 

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

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

  1050 		{

  1091 		{

  1053 

  1093 

  1054 		bufsd = &(iBufs[inout]);

  1094 		bufsd = &(iBufs[inout]);

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

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

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

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

  1057 			{

  1097 			{

  1059 			TInt bufMaxSize=0;

  1099 			TInt bufMaxSize=0;

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

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

  1061 				{

  1101 				{

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

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

  1064 				if (nextEp!=NULL)

  1104 				if (nextEp!=NULL)

  1065 					{

  1105 					{

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

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

  1068 					if (bufferSize> bufMaxSize)

  1108 					if (bufferSize> bufMaxSize)

  1069 						 bufMaxSize = bufferSize;

  1109 						 bufMaxSize = bufferSize;

  1070 					}

  1110 					}

  1071 				} // for altsetting

  1111 				} // for altsetting

  1073 			bufsd->iSizes[endpoint] = bufMaxSize;

  1113 			bufsd->iSizes[endpoint] = bufMaxSize;

  1074 			if (bufMaxSize>0) 

  1114 			if (bufMaxSize>0) 

  1075 				{

  1115 				{

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

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

  1077 				iTotalBuffers++;

  1117 				iTotalBuffers++;

  1120 	iAltSettingsTbl->iEpRecordSize = sizeof(TUint);

  1160 	iAltSettingsTbl->iEpRecordSize = sizeof(TUint);

  1121 	iAltSettingsTbl->iNumOfAltSettings = iAltSettings;

  1161 	iAltSettingsTbl->iNumOfAltSettings = iAltSettings;

  1122 

  1162 

  1123 

  1163 

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

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

  1129 	// 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.

  1130 	// 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.

  1131 

  1169 

  1132 	TInt* noEpForAlt;

  1170 	TInt* noEpForAlt;

  1133 	TInt altSetting;

  1171 	TInt altSetting;

  1135 	if (iAlternateSettingList)

  1173 	if (iAlternateSettingList)

  1136 		{

  1174 		{

  1137 		alt = iAlternateSettingList->iHead;

  1175 		alt = iAlternateSettingList->iHead;

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

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

  1139 			{

  1177 			{

  1142 				iAltSettingsTbl->iAltTableOffset[altSetting] = tableOffset;

  1179 				iAltSettingsTbl->iAltTableOffset[altSetting] = tableOffset;

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

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

  1144 			 

  1181 			 

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

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

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

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

  1187 	  iChunkInfo(NULL),

  1224 	  iChunkInfo(NULL),

  1188 	  iNumBuffers(-1),

  1225 	  iNumBuffers(-1),

  1189 	  iBuffers(NULL),

  1226 	  iBuffers(NULL),

  1190 	  iEp0Endpoint(NULL)

  1227 	  iEp0Endpoint(NULL)

  1191 	{

  1228 	{

  1193 	iClient = &Kern::CurrentThread();

  1231 	iClient = &Kern::CurrentThread();

  1194 	iClient->Open();

  1232 	iClient->Open();

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

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

  1196 		{

  1234 		{

  1197 		iRequestStatus[i] = NULL;

  1235 		iRequestStatus[i] = NULL;

  1203 // Destructor

  1241 // Destructor

  1204 //

  1242 //

  1205 

  1243 

  1206 DLddUsbcScChannel::~DLddUsbcScChannel()

  1244 DLddUsbcScChannel::~DLddUsbcScChannel()

  1207 	{

  1245 	{

  1209 	if (iController)

  1247 	if (iController)

  1210 		{

  1248 		{

  1211 		iController->DeRegisterClient(this);

  1249 		iController->DeRegisterClient(this);

  1212 		iStatusCallbackInfo.Cancel();

  1250 		iStatusCallbackInfo.Cancel();

  1213 		iEndpointStatusCallbackInfo.Cancel();

  1251 		iEndpointStatusCallbackInfo.Cancel();

  1224 		if (iStatusFifo!=NULL)

  1262 		if (iStatusFifo!=NULL)

  1225 			{

  1263 			{

  1226 			delete iStatusFifo;

  1264 			delete iStatusFifo;

  1227 			}

  1265 			}

  1228 		}

  1266 		}

  1230 	if (iBuffers)

  1268 	if (iBuffers)

  1231 		{

  1269 		{

  1232 		TInt i;

  1270 		TInt i;

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

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

  1234 			{

  1272 			{

  1238 		}

  1276 		}

  1239 

  1277 

  1240 	if (iRealizeCalled)

  1278 	if (iRealizeCalled)

  1241 		{

  1279 		{

  1242 		// Close Chunk

  1280 		// Close Chunk

  1243 		iChunkInfo->Close();

  1282 		iChunkInfo->Close();

  1244 		// 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.		

  1245 		iChunkInfo=NULL;

  1284 		iChunkInfo=NULL;

  1246 		}

  1285 		}

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

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

  1249 	}

  1289 	}

  1250 

  1290 

  1251 

  1291 

  1252 //

  1292 //

  1253 // DoCreate - Create channel

  1293 // DoCreate - Create channel

  1254 //

  1294 //

  1255 

  1295 

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

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

  1257 	{

  1297 	{

  1260 	if (!Kern::CurrentThreadHasCapability(ECapabilityCommDD,

  1301 	if (!Kern::CurrentThreadHasCapability(ECapabilityCommDD,

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

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

  1262 		{

  1303 		{

  1263 		return KErrPermissionDenied;

  1304 		return KErrPermissionDenied;

  1264 		}

  1305 		}

  1314 

  1355 

  1315 void DLddUsbcScChannel::HandleMsg(TMessageBase* aMsg)

  1356 void DLddUsbcScChannel::HandleMsg(TMessageBase* aMsg)

  1316 	{

  1357 	{

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

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

  1318 	TInt id = m.iValue;

  1359 	TInt id = m.iValue;

  1321 	if (id == (TInt) ECloseMsg)

  1362 	if (id == (TInt) ECloseMsg)

  1322 		{

  1363 		{

  1323 		iChannelClosing = ETrue;

  1364 		iChannelClosing = ETrue;

  1324 		m.Complete(KErrNone, EFalse);

  1365 		m.Complete(KErrNone, EFalse);

  1325 		return;

  1366 		return;

  1326 		}

  1367 		}

  1327 

  1368 

  1328 	TInt r;

  1369 	TInt r;

  1329 	if (id < 0)

  1375 	if (id < 0)

  1330 		{

  1376 		{

  1331 		// DoRequest

  1377 		// DoRequest

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

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

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

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

  1347 		}

  1393 		}

  1348 	}

  1394 	}

  1349 // end HandleMsg.

  1395 // end HandleMsg.

  1350 

  1396 

  1351 

  1397 

  1354 //

  1398 //

  1355 // DoRequest - Asynchronous requests

  1399 // DoRequest - Asynchronous requests

  1356 //

  1400 //

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

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

  1358 //

  1402 //

  1360 	{

  1404 	{

  1361 	TInt reqNo = aReqNo & RDevUsbcScClient::KFieldIdMask;

  1405 	TInt reqNo = aReqNo & RDevUsbcScClient::KFieldIdMask;

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

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

  1363 	TBool needsCompletion =EFalse;

  1407 	TBool needsCompletion =EFalse;

  1364 

  1408 

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

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

  1368 		(reqNo<RDevUsbcScClient::ERequestMaxRequests))

  1412 		(reqNo<RDevUsbcScClient::ERequestMaxRequests))

  1369 		{

  1413 		{

  1370 		if (iRequestStatus[reqNo])

  1414 		if (iRequestStatus[reqNo])

  1371 			{

  1415 			{

  1378 	switch (reqNo)

  1422 	switch (reqNo)

  1379 		{

  1423 		{

  1380 	case RDevUsbcScClient::ERequestWriteData:

  1424 	case RDevUsbcScClient::ERequestWriteData:

  1381 		{

  1425 		{

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

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

  1385 

  1434 

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

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

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

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

  1388 		break;

  1437 		break;

  1389 		}

  1438 		}

  1390 	case RDevUsbcScClient::ERequestReadDataNotify:

  1439 	case RDevUsbcScClient::ERequestReadDataNotify:

  1391 		{

  1440 		{

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

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

  1394 		} 

  1443 		} 

  1395 

  1444 

  1396 	case RDevUsbcScClient::ERequestAlternateDeviceStatusNotify:

  1445 	case RDevUsbcScClient::ERequestAlternateDeviceStatusNotify:

  1397 		{

  1446 		{

  1400 		iDeviceStatusNeeded = ETrue;

  1454 		iDeviceStatusNeeded = ETrue;

  1401 		iStatusChangePtr = a1;

  1455 		iStatusChangePtr = a1;

  1402 		needsCompletion = AlternateDeviceStateTestComplete();

  1456 		needsCompletion = AlternateDeviceStateTestComplete();

  1403 		break;

  1457 		break;

  1404 		}

  1458 		}

  1405 	case RDevUsbcScClient::ERequestReEnumerate:

  1459 	case RDevUsbcScClient::ERequestReEnumerate:

  1406 		{

  1460 		{

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

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

  1409 		r = iController->ReEnumerate();

  1463 		r = iController->ReEnumerate();

  1410 		break;

  1464 		break;

  1411 		}

  1465 		}

  1412 	case RDevUsbcScClient::ERequestEndpointStatusNotify:

  1466 	case RDevUsbcScClient::ERequestEndpointStatusNotify:

  1413 		{

  1467 		{

  1417 		iEndpointStatusChangePtr = a1;

  1475 		iEndpointStatusChangePtr = a1;

  1418 		break;

  1476 		break;

  1419 		}

  1477 		}

  1420 	case RDevUsbcScClient::ERequestOtgFeaturesNotify:

  1478 	case RDevUsbcScClient::ERequestOtgFeaturesNotify:

  1421 		{

  1479 		{

  1425 		iOtgFeatureChangePtr = a1;

  1487 		iOtgFeatureChangePtr = a1;

  1426 		break;

  1488 		break;

  1427 		}

  1489 		}

  1428     default:

  1490     default:

  1429 		r = KErrNotSupported;

  1491 		r = KErrNotSupported;

  1444 //

  1506 //

  1445 // 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.

  1446 //

  1508 //

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

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

  1448 	{

  1510 	{

  1450 	TInt r = KErrNone;

  1513 	TInt r = KErrNone;

  1451 	// check range

  1514 	// check range

  1452 	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.

  1453 		{

  1516 		{

  1454 		if (aBufferNum!=KUsbcScEndpointZero)

  1517 		if (aBufferNum!=KUsbcScEndpointZero)

  1455 			{

  1518 			{

  1457 			return KErrArgument;

  1521 			return KErrArgument;

  1458 			}

  1522 			}

  1459 		else

  1523 		else

  1460 			{

  1524 			{

  1461 			aBufferNum = iEP0OutBuff;

  1525 			aBufferNum = iEP0OutBuff;

  1464 	else

  1528 	else

  1465 		{

  1529 		{

  1466 		// check direction

  1530 		// check direction

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

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

  1468 			{

  1532 			{

  1470 			return KErrNotSupported;

  1534 			return KErrNotSupported;

  1471 			}

  1535 			}

  1472 		if (!Configured())

  1536 		if (!Configured())

  1473 			return KErrUsbInterfaceNotReady;

  1537 			return KErrUsbInterfaceNotReady;

  1474 		}

  1538 		}

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

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

  1476 

  1540 

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

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

  1480 		r = KErrCompletion;

  1543 		r = KErrCompletion;

  1481 	else

  1544 	else

  1482 		if (iBuffers[aBufferNum].iStalled)

  1545 		if (iBuffers[aBufferNum].iStalled)

  1483 			{

  1546 			{

  1491 		{

  1554 		{

  1492 		iBuffers[aBufferNum].StartDataRead();

  1555 		iBuffers[aBufferNum].StartDataRead();

  1493 		}

  1556 		}

  1494 	else

  1557 	else

  1495 		{

  1558 		{

  1497 		}

  1560 		}

  1498 	return r;

  1561 	return r;

  1499 	}

  1562 	}

  1500 // end DoReadDataNotify.

  1563 // end DoReadDataNotify.

  1501 

  1564 

  1506 //

  1569 //

  1507 // 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.

  1508 //

  1571 //

  1509 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)

  1510 	{

  1573 	{

  1512 	if (!iUserKnowsAltSetting)

  1576 	if (!iUserKnowsAltSetting)

  1513 		return KErrEof;

  1577 		return KErrEof;

  1514 	// Check Buffer Number

  1578 	// Check Buffer Number

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

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

  1516 		{

  1580 		{

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

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

  1518 			{

  1582 			{

  1520 			return KErrArgument;

  1584 			return KErrArgument;

  1521 			}

  1585 			}

  1522 		else

  1586 		else

  1523 			{

  1587 			{

  1524 			aBufferNum = iEP0InBuff;

  1588 			aBufferNum = iEP0InBuff;

  1527 	else

  1591 	else

  1528 		{

  1592 		{

  1529 		// check direction

  1593 		// check direction

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

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

  1531 			{

  1595 			{

  1533 				return KErrArgument;

  1597 				return KErrArgument;

  1534 			}

  1598 			}

  1535 		}

  1599 		}

  1536 

  1600 

  1537 	TUsbcScBuffer& buf=iBuffers[aBufferNum];

  1601 	TUsbcScBuffer& buf=iBuffers[aBufferNum];

  1538 

  1602 

  1539 	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))

  1540 		{

  1604 		{

  1542 		return KErrArgument;

  1606 		return KErrArgument;

  1543 		}

  1607 		}

  1544 

  1608 

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

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

  1546 		return KErrUsbInterfaceNotReady;

  1610 		return KErrUsbInterfaceNotReady;

  1547 

  1611 

  1548 	if (aStart & ~buf.iAlignMask)

  1612 	if (aStart & ~buf.iAlignMask)

  1549 		{

  1613 		{

  1551 		return KErrArgument;

  1616 		return KErrArgument;

  1552 		}

  1617 		}

  1553 			

  1618 			

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

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

  1555 

  1620 

  1557 		{

  1622 		{

  1558 			iBuffers[aBufferNum].StartDataWrite();

  1623 			iBuffers[aBufferNum].StartDataWrite();

  1559 		}

  1624 		}

  1560 	else

  1625 	else

  1561 		{	

  1626 		{	

  1563 		}

  1628 		}

  1564 

  1629 

  1565 

  1630 

  1566 	return r;

  1631 	return r;

  1567 	}

  1632 	}

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

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

  1575 	{

  1640 	{

  1576 	TInt r = KErrNone;

  1641 	TInt r = KErrNone;

  1577 	TInt direction=KUsbcScOut;

  1642 	TInt direction=KUsbcScOut;

  1578 

  1643 

  1580 	switch (aReqNo)

  1646 	switch (aReqNo)

  1581 		{

  1647 		{

  1582 	case RDevUsbcScClient::ERequestCancel:

  1648 	case RDevUsbcScClient::ERequestCancel:

  1583 		TInt buffer;

  1649 		TInt buffer;

  1584 		TInt mask;

  1650 		TInt mask;

  1591 

  1657 

  1592 	// coverity[missing_break]

  1658 	// coverity[missing_break]

  1593 	case RDevUsbcScClient::ERequestWriteDataCancel:

  1659 	case RDevUsbcScClient::ERequestWriteDataCancel:

  1594 		direction = KUsbcScIn;

  1660 		direction = KUsbcScIn;

  1595 	case RDevUsbcScClient::ERequestReadDataNotifyCancel:

  1661 	case RDevUsbcScClient::ERequestReadDataNotifyCancel:

  1598 		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

  1599 			{

  1664 			{

  1601 			iEp0Endpoint->AbortTransfer();

  1666 			iEp0Endpoint->AbortTransfer();

  1602 			if (direction==KUsbcScIn)

  1667 			if (direction==KUsbcScIn)

  1603 				aBuff=iEP0InBuff;

  1668 				aBuff=iEP0InBuff;

  1604 			else

  1669 			else

  1605 				aBuff=iEP0OutBuff;

  1670 				aBuff=iEP0OutBuff;

  1606 			} 

  1671 			} 

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

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

  1608 			{

  1673 			{

  1610 			return KErrArgument;

  1675 			return KErrArgument;

  1611 			}

  1676 			}

  1612 

  1677 

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

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

  1614 			{

  1679 			{

  1616 			return KErrArgument;

  1681 			return KErrArgument;

  1617 			}	

  1682 			}	

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

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

  1619 		iBuffers[aBuff].Cancel(KErrCancel);

  1684 		iBuffers[aBuff].Cancel(KErrCancel);

  1620 		

  1685 		

  1621 		return KErrNone;

  1686 		return KErrNone;

  1622 

  1687 

  1623 	case RDevUsbcScClient::ERequestAlternateDeviceStatusNotifyCancel:

  1688 	case RDevUsbcScClient::ERequestAlternateDeviceStatusNotifyCancel:

  1625 		iDeviceStatusNeeded = EFalse;

  1690 		iDeviceStatusNeeded = EFalse;

  1626 		iStatusFifo->FlushQueue();

  1691 		iStatusFifo->FlushQueue();

  1627 		if (iStatusChangePtr)

  1692 		if (iStatusChangePtr)

  1628 			{

  1693 			{

  1629 			TInt deviceState = iController->GetDeviceStatus();

  1694 			TInt deviceState = iController->GetDeviceStatus();

  1633 			iStatusChangePtr = NULL; 

  1698 			iStatusChangePtr = NULL; 

  1634 			}

  1699 			}

  1635 	break;

  1700 	break;

  1636 

  1701 

  1637 	case RDevUsbcScClient::ERequestReEnumerateCancel:

  1702 	case RDevUsbcScClient::ERequestReEnumerateCancel:

  1639 	break;

  1704 	break;

  1640 

  1705 

  1641 	case RDevUsbcScClient::ERequestEndpointStatusNotifyCancel:

  1706 	case RDevUsbcScClient::ERequestEndpointStatusNotifyCancel:

  1643 		CancelNotifyEndpointStatus();

  1708 		CancelNotifyEndpointStatus();

  1644 	break;

  1709 	break;

  1645 

  1710 

  1646  	case RDevUsbcScClient::ERequestOtgFeaturesNotifyCancel:

  1711  	case RDevUsbcScClient::ERequestOtgFeaturesNotifyCancel:

  1648 		CancelNotifyOtgFeatures();

  1713 		CancelNotifyOtgFeatures();

  1649 	break;

  1714 	break;

  1650 

  1715 

  1651 	default:

  1716 	default:

  1653 		return KErrArgument;

  1718 		return KErrArgument;

  1654 		}

  1719 		}

  1655 

  1720 

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

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

  1657 	return r;

  1722 	return r;

  1697 //

  1762 //

  1698 // Called from HandleMsg.

  1763 // Called from HandleMsg.

  1699 

  1764 

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

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

  1701 	{

  1766 	{

  1704 	TInt r = KErrNone;

  1769 	TInt r = KErrNone;

  1705 	TInt ep, param;

  1770 	TInt ep, param;

  1706 	TUsbcScEndpoint* pEndpoint;

  1771 	TUsbcScEndpoint* pEndpoint;

  1707 	TPtrC8 pZeroDesc(NULL, 0);

  1772 	TPtrC8 pZeroDesc(NULL, 0);

  1708 	TEndpointDescriptorInfo epInfo;

  1773 	TEndpointDescriptorInfo epInfo;

  1711 	TUsbcEndpointResource epRes;

  1776 	TUsbcEndpointResource epRes;

  1712 

  1777 

  1713 	switch (aFunction)

  1778 	switch (aFunction)

  1714 		{

  1779 		{

  1715 	case RDevUsbcScClient::EControlEndpointZeroRequestError:

  1780 	case RDevUsbcScClient::EControlEndpointZeroRequestError:

  1717 		r = KErrNone;

  1782 		r = KErrNone;

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

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

  1719 			{

  1784 			{

  1720 			iController->Ep0Stall(this);

  1785 			iController->Ep0Stall(this);

  1721 			}

  1786 			}

  1727 				r = KErrUsbInterfaceNotReady;

  1792 				r = KErrUsbInterfaceNotReady;

  1728 			}

  1793 			}

  1729 		break;

  1794 		break;

  1730 

  1795 

  1731 	case RDevUsbcScClient::EControlGetAlternateSetting:

  1796 	case RDevUsbcScClient::EControlGetAlternateSetting:

  1733 		if (iValidInterface && iDeviceState == EUsbcDeviceStateConfigured)

  1798 		if (iValidInterface && iDeviceState == EUsbcDeviceStateConfigured)

  1734 			{

  1799 			{

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

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

  1736 			if (r == KErrNone)

  1801 			if (r == KErrNone)

  1737 				{

  1802 				{

  1748 				r = KErrUsbInterfaceNotReady;

  1813 				r = KErrUsbInterfaceNotReady;

  1749 			}

  1814 			}

  1750 		break;

  1815 		break;

  1751 

  1816 

  1752 	case RDevUsbcScClient::EControlDeviceStatus:

  1817 	case RDevUsbcScClient::EControlDeviceStatus:

  1754 		param = iController->GetDeviceStatus();

  1819 		param = iController->GetDeviceStatus();

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

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

  1756 		if (r != KErrNone)

  1821 		if (r != KErrNone)

  1757 			PanicClientThread(r);

  1822 			PanicClientThread(r);

  1758 		break;

  1823 		break;

  1759 

  1824 

  1760 	case RDevUsbcScClient::EControlEndpointStatus:

  1825 	case RDevUsbcScClient::EControlEndpointStatus:

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

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

  1763 			{

  1828 			{

  1764 			pEndpoint = iEndpoint[(TInt)a1];

  1829 			pEndpoint = iEndpoint[(TInt)a1];

  1765 			if (pEndpoint == NULL)

  1830 			if (pEndpoint == NULL)

  1766 				r = KErrNotSupported;

  1831 				r = KErrNotSupported;

  1780 				r = KErrUsbInterfaceNotReady;

  1845 				r = KErrUsbInterfaceNotReady;

  1781 			}

  1846 			}

  1782 		break;

  1847 		break;

  1783 

  1848 

  1784 	case RDevUsbcScClient::EControlEndpointCaps:

  1849 	case RDevUsbcScClient::EControlEndpointCaps:

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

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

  1787 		if (r != KErrNone)

  1852 		if (r != KErrNone)

  1788 			PanicClientThread(r);

  1853 			PanicClientThread(r);

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

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

  1790 		break;

  1855 		break;

  1791 

  1856 

  1792 	case RDevUsbcScClient::EControlDeviceCaps:

  1857 	case RDevUsbcScClient::EControlDeviceCaps:

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

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

  1795 		if (r != KErrNone)

  1860 		if (r != KErrNone)

  1796 			PanicClientThread(r);

  1861 			PanicClientThread(r);

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

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

  1798 		break;

  1863 		break;

  1799 

  1864 

  1800 	case RDevUsbcScClient::EControlSendEp0StatusPacket:

  1865 	case RDevUsbcScClient::EControlSendEp0StatusPacket:

  1802 		iController->SendEp0StatusPacket(this);

  1867 		iController->SendEp0StatusPacket(this);

  1803 		break;

  1868 		break;

  1804 

  1869 

  1805 	case RDevUsbcScClient::EControlHaltEndpoint:

  1870 	case RDevUsbcScClient::EControlHaltEndpoint:

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

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

  1808 			{

  1873 			{