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

 // All rights reserved.

 // This component and the accompanying materials are made available

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

 // which accompanies this distribution, and is available

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

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 /**

  @file

  @internalTechnology

 */

 #include "cbulkonlytransport.h"

 #include "cbulkonlytransportusbcldd.h"

 #include "cbulkonlytransportusbcscldd.h"

 #include "usbmsshared.h"

 #include "massstoragedebug.h"

 #include "cusbmassstorageserver.h"

 //CBW offsets

 LOCAL_D const TInt KCbwSignatureOffset 			= 0;

 LOCAL_D const TInt KCbwTagOffset 				= 4;

 LOCAL_D const TInt KCbwDataTransferLengthOffset = 8;

 LOCAL_D const TInt KCbwFlagOffset 				= 12;

 LOCAL_D const TInt KCbwLunOffset				= 13;

 LOCAL_D const TInt KCbwCbLengthOffset  			= 14;

 LOCAL_D const TInt KMaxCbwcbLength 				= 16;

 // CSW offsets

 LOCAL_D const TInt KCswSingnatureOffset 		= 0;

 LOCAL_D const TInt KCswTagOffset 				= 4;

 LOCAL_D const TInt KCswDataResidueOffset 		= 8;

 LOCAL_D const TInt KCswStatusOffset 			= 12;

 /**

  This function unpacks into the TUsbRequestHdr class from a descriptor with

  the alignment that would be introduced on the USB bus.

  @param aBuffer Input buffer

  @param aTarget Unpacked header.

  @return Error.

  */

 TInt TUsbRequestHdr::Decode(const TDesC8& aBuffer)

 	{

 	if (aBuffer.Length() < static_cast<TInt>(KRequestHdrSize))

 		{

         __PRINT1(_L("TUsbRequestHdr::Decode buffer invalid length %d"), aBuffer.Length());

 		return KErrGeneral;

 		}

 	iRequestType = aBuffer[0];

 	iRequest = static_cast<TEp0Request>(aBuffer[1]);

 	iValue	 = static_cast<TUint16>(aBuffer[2] + (aBuffer[3] << 8));

 	iIndex	 = static_cast<TUint16>(aBuffer[4] + (aBuffer[5] << 8));

 	iLength  = static_cast<TUint16>(aBuffer[6] + (aBuffer[7] << 8));

     __PRINT5(_L("type=%d request=%d value=%d index=%d length=%d"), iRequestType,iRequest,iValue,iIndex,iLength);

 	return KErrNone;

 	}

 /**

 This function determines whether data is required by the host in response

 to a message header.

 @return TBool	Flag indicating whether a data response required.

 */

 TBool TUsbRequestHdr::IsDataResponseRequired() const

 	{

 	return (iRequestType & 0x80) ? (TBool)ETrue : (TBool)EFalse;

 	}

 //-------------------------------------

 /**

 Create an object of a class derived from CBulkOnlyTransport (default to CBulkOnlyTransportUsbcLdd object)

 @param aNumDrives - The number of drives available for MS

 @param aController - reference to the parent

 @return pointer to newly created derived class object

 */

 CBulkOnlyTransport* CBulkOnlyTransport::NewL(TInt aNumDrives,CUsbMassStorageController& aController)

 	{

 	__FNLOG("CBulkOnlyTransport::NewL()");

 	return NewL(aNumDrives,aController, (CUsbMassStorageController::TTransportldd) 1);

 	}

 /**

 Create an object of a class derived from CBulkOnlyTransport 

 @param aNumDrives - The number of drives available for MS

 @param aController - reference to the parent

 @param aTransportLddFlag - Type of usb client ldd

 @return pointer to newly created derived class object

 */

 CBulkOnlyTransport* CBulkOnlyTransport::NewL(TInt aNumDrives,CUsbMassStorageController& aController, CUsbMassStorageController::TTransportldd aTransportLddFlag)

 	{

 	__FNLOG("CBulkOnlyTransport::NewL()");

 	if (aNumDrives <=0 || static_cast<TUint>(aNumDrives) > KUsbMsMaxDrives)

 		{

 		User::Leave(KErrArgument);

 		}

 	CBulkOnlyTransportUsbcScLdd* scTransport;

 	CBulkOnlyTransportUsbcLdd* nonscTransport;

 	switch (aTransportLddFlag)

 		{

 		case 1: 

 				nonscTransport = new(ELeave) CBulkOnlyTransportUsbcLdd(aNumDrives, aController);

 				return nonscTransport;

 		case 2: 

 				scTransport = new(ELeave) CBulkOnlyTransportUsbcScLdd(aNumDrives, aController);

 				return scTransport;

 		default:

 				return NULL;

 		}

 	}

 TInt CBulkOnlyTransport::InitialiseTransportL(TInt aTransportLddFlag)

 	{

 	__FNLOG("CBulkOnlyTransportUsbcScLdd::InitialiseTransportL()");

 	TInt ret = KErrNone;

 	MTransportBase* transport;

 	iController.GetTransport(transport);

 	switch (aTransportLddFlag)

 		{

 		case 2: 

 				ret = ((CBulkOnlyTransportUsbcScLdd*) transport)->Ldd().Open(0);

 				if (ret != KErrNone)

 					{

 					return ret;

 					}

 				else

 					{

 					((CBulkOnlyTransportUsbcScLdd*) transport)->Ldd().Close();		

 					CleanupStack::PushL(transport);

 					((CBulkOnlyTransportUsbcScLdd*) transport)->ConstructL();

 					CleanupStack::Pop(transport);

 					return ret;

 					}

 		case 1:

 				ret = ((CBulkOnlyTransportUsbcLdd*) transport)->Ldd().Open(0);

 				if (ret != KErrNone)

 					{

 					return ret;

 					}

 				else

 					{

 					((CBulkOnlyTransportUsbcLdd*) transport)->Ldd().Close();

 					CleanupStack::PushL(transport);

 					((CBulkOnlyTransportUsbcLdd*) transport)->ConstructL();

 					CleanupStack::Pop(transport);

 					return ret;

 					}

 		default:

 				return KErrNotFound;

 		}

 	}	

 /**

 c'tor

 @param aNumDrives - The number of drives available for MS

 @param aController - reference to the parent

 */

 CBulkOnlyTransport::CBulkOnlyTransport(TInt aNumDrives,CUsbMassStorageController& aController):

 	CActive(EPriorityStandard),

 	iMaxLun(aNumDrives-1),

 	iController(aController),

 	iStallAllowed(ETrue),

 	iInterfaceConfigured(EFalse),

 	iCommandBufPtr(NULL,0),

 	iDataBufPtr(NULL,0),

 	iCswBufPtr(NULL,0),

 	iPaddingBufPtr(NULL,0),

 	iWriteBufPtr(NULL,0),

 	iReadBufPtr(NULL, 0),

 	iCbwBufPtr(NULL,0)

 	{

 	__FNLOG("CBulkOnlyTransport::CBulkOnlyTransport");

 	}

 /**

 Destructor

 */

 CBulkOnlyTransport::~CBulkOnlyTransport()

 	{

 	__FNLOG("CBulkOnlyTransport::~CBulkOnlyTransport");

 	if (iInterfaceConfigured)

 		{

 		Stop();

 		}

 	}

 /**

 Called by the protocol after processing the packet to indicate that more data is required.

 @param aData reference to the data buffer.

 */

 void CBulkOnlyTransport::SetupReadData(TUint aLength)

 	{

 	__FNLOG("CBulkOnlyTransport::SetupReadData");

 	__PRINT1(_L("Length = %d  (bytes)\n"), aLength);

 	iBufSize = aLength;

 	iReadSetUp = ETrue;

 	}

 /**

 Called by the protocol after processing the packet to indicate that data should be written to the host.

 @param aData reference to the data buffer.

 */

 void CBulkOnlyTransport::SetupWriteData(TPtrC8& aData)

 	{

 	__FNLOG("CBulkOnlyTransport::SetupWriteData");

 	__PRINT1(_L("Length = %d  (bytes)\n"), aData.Length());

 	iWriteBufPtr.Set(aData);

 	iWriteSetUp = ETrue;

 	}

 TInt CBulkOnlyTransport::Start()

 	{

 	__FNLOG("CBulkOnlyTransport::Start");

 	TInt err = KErrNone;

 	if (!iProtocol)

 		{

 		return KErrBadHandle;   //protocol should be set up before start

 		}

 	if (IsActive())

 		{

 		__PRINT(_L("CBulkOnlyTransport::Start  - active before start!\n"));

 		return KErrInUse;

 		}

 	if ((err = SetupConfigurationDescriptor()) 	!= KErrNone ||

 		(err = SetupInterfaceDescriptors())		!= KErrNone )

 		{

 		__PRINT(_L("CBulkOnlyTransport::Start  - Error during descriptors setup!\n"));

 		return err;

 		}

 	AllocateEndpointResources();

 	ActivateDeviceStateNotifier();  // activate notifier wich will wait until USB became configured

 	TUsbcDeviceState deviceStatus = EUsbcDeviceStateDefault;

 	err = GetDeviceStatus(deviceStatus);

 	__PRINT1(_L("CBulkOnlyTransport::Start - Device status = %d\n"), deviceStatus);

 	if (err == KErrNone && deviceStatus == EUsbcDeviceStateConfigured)

 		{

 		__PRINT(_L("CBulkOnlyTransport::Start  - Starting bulk only transport\n"));

 		err = HwStart();

 		}

 #ifdef MSDC_MULTITHREADED

 	TPtr8 aDes1(NULL,0);

 	TPtr8 aDes2(NULL,0);

 	GetBufferPointers(aDes1, aDes2);

 	iProtocol->InitializeBufferPointers(aDes1, aDes2); // have to pass pointer to memory not offsets to initialise TPtr, and lengths

 #endif

 	iInterfaceConfigured = ETrue;

 	return err;

 	}

 TInt CBulkOnlyTransport::HwStart(TBool aDiscard)

 	{

 	__FNLOG("CBulkOnlyTransport::HwStart");

     TInt lun = MaxLun();

     do

         {

         Controller().DriveManager().Connect(lun);

         }

     while(--lun >= 0);

 	TInt res = StartControlInterface();

 	iCurrentState = ENone;

 	iWriteSetUp=EFalse;

 	iReadSetUp=EFalse;

 	iStarted = ETrue;

     if (aDiscard)

 		{

 		FlushData();

 		}

 	ReadCBW();

 	return res;

 	}

 TInt CBulkOnlyTransport::HwStop()

 	{

 	__FNLOG("CBulkOnlyTransport::HwStop");

 	if (iStarted)

 		{

         StopBulkOnlyEndpoint();

 		CancelControlInterface();

 		iStarted = EFalse;

 		}

 	return KErrNone;

 	}

 void CBulkOnlyTransport::StopBulkOnlyEndpoint()

 	{

 	__FNLOG("CBulkOnlyTransport::StopBulkOnlyEndpoint");

     TInt lun = MaxLun();

     do

         {

         Controller().DriveManager().Disconnect(lun);

         }

     while(--lun >= 0);

 	Cancel();

 	iProtocol->Cancel();

 	}

 TInt CBulkOnlyTransport::HwSuspend()

 	{

 	__FNLOG("CBulkOnlyTransport::HwSuspend");

 	TInt lun = MaxLun();

 	do

 		{

 		Controller().DriveManager().Disconnect(lun);

 		}

 	while(--lun >= 0);

 	return KErrNone;

 	}

 TInt CBulkOnlyTransport::HwResume()

 	{

 	__FNLOG("CBulkOnlyTransport::HwResume");

     TInt lun = MaxLun();

     do

         {

         Controller().DriveManager().Connect(lun);

         }

     while(--lun >= 0);

 	return KErrNone;

 	}

 /**

 Stops the Bulk Only Transport

 */

 TInt CBulkOnlyTransport::Stop()

 	{

 	__FNLOG("CBulkOnlyTransport::Stop");

 	CancelControlInterface();

 	CancelDeviceStateNotifier();

 	Cancel();

 	if  (iInterfaceConfigured)

 		{

 		ReleaseInterface();

 		SetupConfigurationDescriptor(ETrue);

 		}

 	iCurrentState = ENone;

 	iInterfaceConfigured = EFalse;

 	return KErrNone;

 	}

 void CBulkOnlyTransport::DoCancel()

 	{

 	__FNLOG("CBulkOnlyTransport::DoCancel");

 	CancelReadWriteRequests();

 	}

 void CBulkOnlyTransport::Activate(TInt aReason)

     {

     SetActive();

     TRequestStatus* r = &iStatus;

     User::RequestComplete(r, aReason);

     }

 void CBulkOnlyTransport::RunL()

 	{

 	__FNLOG("CBulkOnlyTransport::RunL");

 	if (iStatus != KErrNone)

 		{

 		__PRINT1(_L("Error %d in RunL, halt endpoints \n"), iStatus.Int());

 		SetPermError(); //halt endpoints for reset recovery

 		return;

 		}

 	switch (iCurrentState)

 		{

 		case EWaitForCBW:

 			__PRINT(_L("EWaitForCBW"));

 			ProcessCbwEvent();

 			break;

 		case EWritingData:

             __PRINT(_L("EWritingData"));

 			iWriteSetUp = EFalse;  //the buffer was used

 			if (iDataResidue && iStallAllowed)

 				{

 				StallEndpointAndWaitForClear();

 				}

 			SendCSW(iCbwTag, iDataResidue, iCmdStatus);

 			break;

 		case EReadingData:

 			{

 			__PRINT(_L("EReadingData"));

 			ProcessReadingDataEvent();

 			}

 			break;

 		case ESendingCSW:

 			__PRINT(_L("ESendingCSW"));

 			ReadCBW();

 			break;

         case EPermErr:

 			__PRINT(_L("EPermErr"));

 			StallEndpointAndWaitForClear();

             break;

         default:

 			SetPermError();		// unexpected state

 		}

 	}

 /**

 Decode the CBW received from the host via OutEndpoint

 - If the header is valid, the data content is passed to the parser.

 - Depending on the command, more data may be transmitted/received.

 - ...or the CSW is sent (if not a data command).

 */

 void CBulkOnlyTransport::DecodeCBW()

 	{

 	__FNLOG("CBulkOnlyTransport::DecodeCBW");

 	SetCbwPtr();

 	if (!CheckCBW())  //check if CBW valid and meaningful

 		{

         // CBW not valid or meaningful

         // Specification says: "If the CBW is not valid, the device shall STALL

         // the Bulk-In pipe. Also, the device shall either STALL the Bulk-Out pipe,

         // or the device shall accept and discard any Bulk-Out data. The device

         // shall maintain this state until a Reset Recovery."

         // Here we keep bulk-in ep stalled and ignore bulk-out ep.

 		SetPermError();

 		ExpireData((TAny*) (iCbwBufPtr.Ptr()));

 		return;

 		}

 	TPtrC8 aData;

 	aData.Set(&iCbwBufPtr[KCbwCbLengthOffset], KMaxCbwcbLength+1);    //prepare data for protocol starting form Length

 	TUint8 lun = static_cast<TUint8>(iCbwBufPtr[13] & 0x0f);

 	iCbwTag  =	static_cast<TUint32>(iCbwBufPtr[KCbwTagOffset])		|

 				static_cast<TUint32>(iCbwBufPtr[KCbwTagOffset+1])	<<8 |

 				static_cast<TUint32>(iCbwBufPtr[KCbwTagOffset+2])	<<16|

 				static_cast<TUint32>(iCbwBufPtr[KCbwTagOffset+3])	<<24;

 	TInt i = KCbwDataTransferLengthOffset;

 	TUint hostDataLength = 	static_cast<TUint32>(iCbwBufPtr[i  ])		|

 							static_cast<TUint32>(iCbwBufPtr[i+1]) <<8 	|

 							static_cast<TUint32>(iCbwBufPtr[i+2]) <<16	|

 							static_cast<TUint32>(iCbwBufPtr[i+3]) <<24;

 	TBool dataToHost = iCbwBufPtr[KCbwFlagOffset] & 0x80;

 	__PRINT4(_L("lun =%d, hostDataLength=%d, CBWtag = 0x%x, dataToHost=%d\n"), lun, hostDataLength, iCbwTag, dataToHost);

 	//////////////////////////////////////////////

 	TBool ret = iProtocol->DecodePacket(aData, lun);

 	//////////////////////////////////////////////

 	ExpireData((TAny*) (iCbwBufPtr.Ptr()));

 	iStallAllowed = ETrue;

 	if (!ret)

 		{

 		__PRINT(_L("Command Failed\n"));

 		iCmdStatus = ECommandFailed;

 		}

 	else

 		{

 		__PRINT(_L("Command Passed\n"));

 		iCmdStatus = ECommandPassed;

 		}

 	if (hostDataLength)    // Host  expected data transfer

 		{

 		if (dataToHost)  // send data to host

 			{

 			if (!iWriteSetUp) //write buffer was not set up

 				{

 				__PRINT(_L("Write buffer was not setup\n"));

 				iDataResidue =hostDataLength;

 				__PRINT1(_L("DataResidue (write to host)=%d\n"),iDataResidue);

 //------------------------------------

 				if (hostDataLength <= KBOTMaxBufSize)

 					{

 					__PRINT(_L("Case 4 or 8\n"));

 					SetPaddingBufPtr(hostDataLength);

 					iPaddingBufPtr.FillZ(hostDataLength);

 					TPtrC8 ptr(NULL, 0);

 					ptr.Set((TUint8*)iPaddingBufPtr.Ptr(), hostDataLength);

 					WriteData(iStatus, ptr, hostDataLength, EFalse);

 					iStallAllowed = EFalse;

 					if (iReadSetUp)  //read buffer WAS set up - case (8)

 						{

 						__PRINT(_L("It is Case 8\n"));

 						iCmdStatus = EPhaseError;

 						}

 					return;

 					}

 				else

 //------------------------------------

 //					Use next block instead of StallEndpointAndWaitForClear(InEndpoint);

 					{

 					SetPaddingBufPtr(hostDataLength);

 					iPaddingBufPtr.FillZ(KBOTMaxBufSize);

 					TUint c =0;

 					TRequestStatus status;

 					while (c<hostDataLength)

 						{

 						TInt len;

 						if (hostDataLength - c >  KBOTMaxBufSize)

 							{

 							len = KBOTMaxBufSize;

 							}

 						else

 							{

 							len = hostDataLength - c;

 							}

 							TPtrC8 ptr(NULL, 0);

 							ptr.Set((TUint8*)iPaddingBufPtr.Ptr(), len);

 							WriteUsb(status, ptr, len);

 							User::WaitForRequest(status);

 							c +=  KBOTMaxBufSize;

 						}

 					}

 				if (iReadSetUp)  //read buffer WAS set up - case (8)

 					{

 					__PRINT(_L("Case 8\n"));

 					SendCSW(iCbwTag, hostDataLength, EPhaseError);

 					  //don't care to reset any flag - should get reset recovery

 					}

 				else   // case (4)

 					{

 					__PRINT(_L("Case 4\n"));

 					SendCSW(iCbwTag, hostDataLength, iCmdStatus);

 					}

 				return;

 				}	// if (!iWriteSetUp)

 //==================

 			TUint deviceDataLength = static_cast<TUint>(iWriteBufPtr.Length());

 			iDataResidue =hostDataLength - deviceDataLength ;

 			__PRINT2(_L("Device data length = %d, DataResidue (write to host)=%d\n"), deviceDataLength, iDataResidue);

 			if (deviceDataLength < hostDataLength  &&

 				hostDataLength < KBOTMaxBufSize )

 					{

 					__PRINT(_L("Case 5 (padding)\n"));

 					SetPaddingBufPtr(hostDataLength);

 					iPaddingBufPtr.Zero();

 					iPaddingBufPtr.Append(iWriteBufPtr);

 					iStallAllowed = EFalse;

 					__PRINT1(_L("iPaddingBufPtr.Length = %d\n"),iPaddingBufPtr.Length());

 					TPtrC8 ptr(NULL, 0);

 					ptr.Set((TUint8*)iPaddingBufPtr.Ptr(), hostDataLength);

 					WriteData(iStatus, ptr, hostDataLength, EFalse);

 					return;

 					}

 //===================

 			if (deviceDataLength == hostDataLength)  	//case (6)[==]

 				{

 				__PRINT(_L("Case 6\n"));

 				WriteData(iStatus, iWriteBufPtr, deviceDataLength);

 				return;

 				}

 			else if (deviceDataLength < hostDataLength)	//case (5)[<]

 				{

 				__PRINT(_L("Case 5\n"));

 				WriteData(iStatus, iWriteBufPtr, deviceDataLength, ETrue);		// Send ZLP

 				return;

 				}

 			else 										// deviceDataLength > hostDataLength - case (7)

 				{

 				__PRINT(_L("Case 7\n"));

 				iCmdStatus = EPhaseError;

 				iDataResidue = 0;

 				WriteData(iStatus, iWriteBufPtr, hostDataLength);

 				return;

 				}

 			}

 		else  //read data from host

 			{

 			if (!iReadSetUp)

 				{

 				iDataResidue = hostDataLength;

 				__PRINT(_L("Read buffer was not setup\n"));

 //				Use next block instead of StallEndpointAndWaitForClear(OutEndpoint);

 				DiscardData(hostDataLength);

 				if (iWriteSetUp) //case (10)

 					{

 					__PRINT(_L("case 10\n"));

 					SendCSW(iCbwTag, hostDataLength, EPhaseError);

 					}

 				else // case (9)

 					{

 					__PRINT(_L("Case 9\n"));

 					SendCSW(iCbwTag, hostDataLength, iCmdStatus);

 					}

 				return;

 				}

 			TUint deviceDataLength = iBufSize;

 			iDataResidue = hostDataLength;  // calculate residue later

 			__PRINT2(_L("deviceDataLength = iBufSize = %d, DataResidue = HDL for now (read from host) =%d\n"),deviceDataLength,iDataResidue);

 			if (deviceDataLength <= hostDataLength)  // case (11) and (12)

 				{

 				__PRINT(_L("Case 11 or 12\n"));

 				ReadData(deviceDataLength);

 				return;

 				}

 			if (deviceDataLength > hostDataLength) // case  (13)

 				{

 				__PRINT(_L("Case 13\n"));

                 /**

                  * Comment following line in order to pass compliant test.

                  * As spec said in case 13:"The device may receive data up to a

                  * total of dCBWDataTransferLength."

                  * Here we choose to ignore incoming data.

                  */

 				//StallEndpointAndWaitForClear(OutEndpoint); //Stall Out endpoint

                 if (iReadSetUp)

                     {

 					WriteToClient(hostDataLength);

                     iReadSetUp = EFalse;

                     }

                 SendCSW(iCbwTag, hostDataLength, EPhaseError);

 				return;

 				}

 			}

 		}

 	else  // Host expected no data transfer

 		{

 		__PRINT(_L("No data transfer expected\n"));

 		iDataResidue = 0;

 		if (iWriteSetUp || iReadSetUp)   // case (2) and (3)

 			{

 			__PRINT(_L("Case 2 or 3\n"));

 			SendCSW(iCbwTag, 0, EPhaseError);

 			}

 		else

 			{

 			__PRINT(_L("Case 1\n"));

 			SendCSW(iCbwTag, 0, iCmdStatus);  //case (1)

 			}

 		}

 	}

 /**

 Check if CBW Valid and Meaningful.

 @return ETrue if CBW is Valid and Meaningful, EFalse otherwise

 */

 TBool CBulkOnlyTransport::CheckCBW()

 	{

 	__FNLOG("CBulkOnlyTransport::CheckCBW");

     //

     // Check valid

     //

     // Check length

     if ((TUint) (iCbwBufPtr.Length()) != KCbwLength)

         {

 		__PRINT2(_L("Bad length: %d != KCbwLength"), iCbwBufPtr.Length(), KCbwLength);

 		return EFalse;

         }

     // Check signature

 	TInt i = KCbwSignatureOffset;

 	if (iCbwBufPtr[i  ] != 0x55 ||         // CBW Singature from USB Bulk-Only Transport spec

 		iCbwBufPtr[i+1] != 0x53 ||

 		iCbwBufPtr[i+2] != 0x42 ||

 		iCbwBufPtr[i+3] != 0x43)

 		{

 		__PRINT(_L("Bad signature"));

 		__PRINT4(_L(" 0x%x, 0x%x, 0x%x, 0x%x \n"), iCbwBufPtr[i], iCbwBufPtr[i+1], iCbwBufPtr[i+2],iCbwBufPtr[i+3])

 		return EFalse;

 		}

     //

     // Check meaningful

     //

     // Check reserved bits ( must be zero )

     if ((iCbwBufPtr[KCbwLunOffset] & 0xF0) || (iCbwBufPtr[KCbwCbLengthOffset] & 0xE0))

 		{

 		__PRINT(_L("Reserved bits not zero\n"));

 		return EFalse;

 		}

 	// check command block length

 	TInt cbwcbLength = iCbwBufPtr[KCbwCbLengthOffset] & 0x1F;

 	if (cbwcbLength >KMaxCbwcbLength)

 		{

 		__PRINT(_L("Incorrect block length\n"));

 		return EFalse;

 		}

 	//check LUN

 	TInt8 lun = static_cast<TUint8>(iCbwBufPtr[KCbwLunOffset] & 0x0f);

 	if (iMaxLun < lun)

 		{

 		__PRINT1(_L("bad lun: %d"), lun);

 		return EFalse;

 		}

 	return ETrue;

 	}

 /**

 Initiate stalling of bulk IN endpoint.

 Used when protocol wants to force host to initiate a reset recovery.

 */

 void CBulkOnlyTransport::SetPermError()

 	{

 	__FNLOG("CBulkOnlyTransport::SetPermError");

     iCurrentState = EPermErr;

     Activate(KErrNone);

 	}

 /**

 Send data provided by protocol to the host

 @param aLength amount of data (in bytes) to be send to host

 */

 void CBulkOnlyTransport::WriteData(TRequestStatus& aStatus, TPtrC8& aDes, TUint aLength, TBool aZlpRequired)

 	{

 	__FNLOG("CBulkOnlyTransport::WriteData");

 	if (IsActive())

 		{

 		__PRINT(_L("Still active\n"));

 		__ASSERT_DEBUG(EFalse, User::Panic(KUsbMsSvrPncCat, EMsBulkOnlyStillActive));

 		return;

 		}

 	WriteUsb(aStatus, aDes, aLength, aZlpRequired);

 	iCurrentState = EWritingData;

 	SetActive();

 	}

 /**

 Send Command Status Wrapper to the host

 @param aTag Echo of Command Block Tag sent by the host.

 @param aDataResidue the difference between the amount of data expected by the

        host, and the actual amount of data processed by the device.

 @param aStatus indicates the success or failure of the command.

 */

 void CBulkOnlyTransport::SendCSW(TUint aTag, TUint aDataResidue, TCswStatus aStatus)

 	{

 	__FNLOG("CBulkOnlyTransport::SendCSW");

 	__PRINT2(_L("DataResidue = %d, Status = %d \n"), aDataResidue, aStatus);

 	if (IsActive())

 		{

 		__PRINT(_L("Still active\n"));

 		__ASSERT_DEBUG(EFalse, User::Panic(KUsbMsSvrPncCat, EMsBulkOnlyStillActive));

 		return;

 		}

 	SetCswBufPtr(KCswLength);

 	TInt i = KCswSingnatureOffset;

 	iCswBufPtr[i  ] = 0x55;   // CSW Singature from USB Bulk-Only Transport spec

 	iCswBufPtr[i+1] = 0x53;

 	iCswBufPtr[i+2] = 0x42;

 	iCswBufPtr[i+3] = 0x53;

 	i = KCswTagOffset;

 	iCswBufPtr[i  ] = static_cast<TUint8>((aTag & 0x000000FF));

 	iCswBufPtr[i+1] = static_cast<TUint8>((aTag & 0x0000FF00) >> 8);

 	iCswBufPtr[i+2] = static_cast<TUint8>((aTag & 0x00FF0000) >> 16);

 	iCswBufPtr[i+3] = static_cast<TUint8>((aTag & 0xFF000000) >> 24);

 	i = KCswDataResidueOffset;

 	iCswBufPtr[i  ] = static_cast<TUint8>((aDataResidue & 0x000000FF));

 	iCswBufPtr[i+1] = static_cast<TUint8>((aDataResidue & 0x0000FF00) >> 8);

 	iCswBufPtr[i+2] = static_cast<TUint8>((aDataResidue & 0x00FF0000) >> 16);

 	iCswBufPtr[i+3] = static_cast<TUint8>((aDataResidue & 0xFF000000) >> 24);

 	iCswBufPtr[KCswStatusOffset] = static_cast<TUint8>(aStatus);

 	TPtrC8 ptr(NULL, 0);

 	ptr.Set((const TUint8*)iCswBufPtr.Ptr(), KCswLength);

 	WriteUsb(iStatus, ptr, KCswLength);

 	iCurrentState = ESendingCSW;

 	SetActive();

 	}

 /**

 Associates the transport with the protocol.  Called during initialization of the controller.

 @param aProtocol reference to the protocol

 */

 void CBulkOnlyTransport::RegisterProtocol(MProtocolBase& aProtocol)

 	{

 	__FNLOG("CBulkOnlyTransport::RegisterProtocol");

 	iProtocol = &aProtocol;

 	}

 /**

 Used by CControlInterface

 @return reference to the controller which instantiate the CBulkOnlyTransport

 */

 CUsbMassStorageController& CBulkOnlyTransport::Controller()

 	{

 	return iController;

 	}

 /**

 @return the number of logical units supported by the device.

 Logical Unit Numbers on the device shall be numbered contiguously starting from LUN

 0 to a maximum LUN of 15 (Fh).

 */

 TInt CBulkOnlyTransport::MaxLun()

 	{

 	return iMaxLun;

 	}

 void CBulkOnlyTransport::GetCommandBufPtr(TPtr8& aDes, TUint aLength) // Set pointer to buffer of specified aLength for command

 	{

 	aDes.Set(SetCommandBufPtr(aLength));

 	}

 void CBulkOnlyTransport::GetReadDataBufPtr(TPtr8& aDes) // Set pointer to buffer into which data is to be read from drive (Read10)

 	{

 	aDes.Set(SetDataBufPtr());

 	}

 void CBulkOnlyTransport::GetWriteDataBufPtr(TPtrC8& aDes) // Set pointer to buffer from which data is to be written to drive (Write10)

 	{

 	aDes.Set(iReadBufPtr);

 	}

 #ifdef MSDC_MULTITHREADED

 void CBulkOnlyTransport::ProcessReadData(TAny* aAddress)

 	{

 	ExpireData(aAddress);

 	}

 #endif