/*

* 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 "cbulkonlytransportusbcscldd.h"

#include "usbmsshared.h"

#include "massstoragedebug.h"

#include "cusbmassstorageserver.h"

//This value defined in USB Mass Storage Bulk Only Transrt spec and not supposed to be changed

LOCAL_D const TInt KRequiredNumberOfEndpoints = 2; // in addition to endpoint 0.

LOCAL_D const TInt KUsbNumInterfacesOffset = 4;

#ifdef MSDC_MULTITHREADED

//Only used in DB. The first 2K of KMaxScBufferSize for sending CSW 

static const TUint32 KCswBufferSize = 2 * 1024;

#endif

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

/**

Called by CBulkOnlyTransportUsbcScLdd to create an instance of CControlInterfaceUsbcScLdd

@param aParent reference to the CBulkOnlyTransportUsbcScLdd

*/

CControlInterfaceUsbcScLdd* CControlInterfaceUsbcScLdd::NewL(CBulkOnlyTransportUsbcScLdd& aParent)

	{

	CControlInterfaceUsbcScLdd* self = new(ELeave) CControlInterfaceUsbcScLdd(aParent);

	CleanupStack::PushL(self);

	self->ConstructL();

	CActiveScheduler::Add(self);

	CleanupStack::Pop();

	return self;

	}

void CControlInterfaceUsbcScLdd::ConstructL()

	{

	}

/**

c'tor

@param aParent reference to the CBulkOnlyTransportUsbcScLdd

*/

CControlInterfaceUsbcScLdd::CControlInterfaceUsbcScLdd(CBulkOnlyTransportUsbcScLdd& aParent)

	:CActive(EPriorityStandard),

	 iParent(aParent),

	 iCurrentState(ENone)

	{

	}

/**

d'tor

*/

CControlInterfaceUsbcScLdd::~CControlInterfaceUsbcScLdd()

	{

	__FNLOG("CControlInterfaceUsbcScLdd::~CControlInterfaceUsbcScLdd ");

	Cancel();

	iEp0Buf.Close();

	}

TInt CControlInterfaceUsbcScLdd::OpenEp0()

	{

	TInt res = iParent.Ldd().OpenEndpoint(iEp0Buf,0);

	return res;

	}

/**

Called by CBulkOnlyTransport HwStart to start control interface

*/

TInt CControlInterfaceUsbcScLdd::Start()

	{

	__FNLOG("CControlInterfaceUsbcScLdd::Start ");

	TInt res = ReadEp0Data();

	return (res);

	}

/**

Called by desctructor of CBulkOnlyTransportUsbcScLdd to stop control interface

*/

void CControlInterfaceUsbcScLdd::Stop()

	{

	__FNLOG("CControlInterfaceUsbcScLdd::Stop ");

	if (!IsActive())

		{

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

		return;

		}

	__PRINT(_L("\nStopping...\n"));

	iCurrentState = ENone;

	Cancel();

	}

/**

Cancel outstanding request (if any)

*/

void CControlInterfaceUsbcScLdd::DoCancel()

	{

	__FNLOG("CControlInterfaceUsbcScLdd::DoCancel ");

	switch(iCurrentState)

		{

		case EReadEp0Data:

			iParent.Ldd().ReadCancel(KUsbcScEndpointZero);

			break;

		case ESendMaxLun:

			iParent.Ldd().WriteCancel(KUsbcScEndpointZero);

			break;

		default:

			__PRINT(_L("\nWrong state !\n"));

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

		}

	}

/**

Implement CControlInterfaceUsbcScLdd state machine

*/

void CControlInterfaceUsbcScLdd::RunL()

	{

	__FNLOG("CControlInterfaceUsbcScLdd::RunL ");

	if (iStatus != KErrNone)

		{

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

		//read EP0  again

		ReadEp0Data();

		return;

		}

	ReadEp0Data();

	}

/**

Actual Read to RDevUsbcScClient BIL

*/

TInt CControlInterfaceUsbcScLdd::ReadUsbEp0()

	{

	iCurrentState = EReadEp0Data;

	iStatus = KRequestPending;

	return iEp0Buf.GetBuffer (iEp0Packet,iEp0Size,iEp0Zlp,iStatus);

	}

/**

Post a read request to EEndpoint0 to read request header

*/

TInt CControlInterfaceUsbcScLdd::ReadEp0Data()

	{

	__FNLOG("CControlInterfaceUsbcScLdd::ReadEp0Data ");

	if (IsActive())

		{

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

		return KErrServerBusy;

		}

	TInt r = KErrNone;

	do

		{

		r = ReadUsbEp0();

		if (r == KErrCompletion)

			{

			iStatus = KErrNone;

			DecodeEp0Data();

			}

		else if (r == KErrNone)

			{

			SetActive();

			}

		} while (((r == KErrCompletion) || (r == TEndpointBuffer::KStateChange)) && (!IsActive()));

	return KErrNone;

	}

/**

Decode request header and do appropriate action - get max LUN info or post a reset request

*/

void CControlInterfaceUsbcScLdd::DecodeEp0Data()

	{

	__FNLOG("CControlInterfaceUsbcScLdd::DecodeEp0Data ");

	if (IsActive())

		{

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

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

		return;

		}

	TPtrC8 ep0ReadDataPtr((TUint8*)iEp0Packet, iEp0Size);

	TInt err = iRequestHeader.Decode(ep0ReadDataPtr);

	if(err != KErrNone)

		return;

    switch(iRequestHeader.iRequest)

		{

		//

		// GET MAX LUN (0xFE)

		//

		case TUsbRequestHdr::EReqGetMaxLun:

			{

			__PRINT1(_L("DecodeEp0Data : 'Get Max LUN' Request MaxLun = %d"),iParent.MaxLun() );

            if (   iRequestHeader.iRequestType != 0xA1 //value from USB MS BOT spec

                || iRequestHeader.iIndex > 15

                || iRequestHeader.iValue != 0

                || iRequestHeader.iLength != 1)

                {

    		    __PRINT(_L("GetMaxLun command packet check error"));

                iParent.Ldd().EndpointZeroRequestError();

                break;

                }

			TPtr8* ep0WriteDataPtr = NULL;

			TUint ep0Length;

			iEp0Buf.GetInBufferRange(((TAny*&)ep0WriteDataPtr),ep0Length);

			ep0WriteDataPtr->SetLength(1);	//Return only 1 byte to host

			ep0WriteDataPtr->Fill(0);

			ep0WriteDataPtr->Fill(iParent.MaxLun());	// Supported Units

			TInt length = ep0WriteDataPtr->Length();

			err = iEp0Buf.WriteBuffer((TPtr8*)(ep0WriteDataPtr->Ptr()),length,ETrue,iStatus);

			iCurrentState = ESendMaxLun;

			SetActive();

			return;

			}

		//

		// RESET (0xFF)

		//

		case TUsbRequestHdr::EReqReset:

			{

			__PRINT(_L("DecodeEp0Data : 'Mass Storage Reset' Request"));

            if (   iRequestHeader.iRequestType != 0x21 //value from USB MS BOT spec

                || iRequestHeader.iIndex > 15

                || iRequestHeader.iValue != 0

                || iRequestHeader.iLength != 0)

                {

			    __PRINT(_L("MSC Reset command packet check error"));

                iParent.Ldd().EndpointZeroRequestError();

                break;

                }

			iParent.HwStop();

			iParent.Controller().Reset();

			iParent.HwStart(ETrue);

            err = iParent.Ldd().SendEp0StatusPacket();

			return;

			}

		//

		// Unknown?

		//

		default:

			{

			__PRINT(_L("DecodeEp0Data : Unknown Request"));

			}

		}

		ReadEp0Data();  //try to get another request

	}

//

// --- class CBulkOnlyTransportUsbcScLdd ---------------------------------------------------------

//

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

	:CBulkOnlyTransport(aNumDrives, aController)

	{

	__FNLOG("CBulkOnlyTransportUsbcScLdd::CBulkOnlyTransportUsbcScLdd");

	}

/**

Constructs the CBulkOnlyTransportUsbcScLdd object

*/

void CBulkOnlyTransportUsbcScLdd::ConstructL()

	{

	__FNLOG("CBulkOnlyTransportUsbcScLdd::ConstructL()");

	iControlInterface = CControlInterfaceUsbcScLdd::NewL(*this);

	iDeviceStateNotifier = CActiveDeviceStateNotifierBase::NewL(*this, *this);

	iChunk = new RChunk();

	CActiveScheduler::Add(this);

	}

CBulkOnlyTransportUsbcScLdd::~CBulkOnlyTransportUsbcScLdd()

	{

	__FNLOG("CBulkOnlyTransportUsbcScLdd::~CBulkOnlyTransportUsbcScLdd");

	if (iInterfaceConfigured)

		{

		TInt err = iSCReadEndpointBuf.Close(); 

		err = iSCWriteEndpointBuf.Close();

		delete iControlInterface ;

		delete iDeviceStateNotifier;

		delete iChunk;

		}

	}	

RDevUsbcScClient& CBulkOnlyTransportUsbcScLdd::Ldd()

	{

	return iLdd;

	}

/**

Set or unset configuration descriptor for USB MassStorage Bulk Only transport

@param aUnset indicate whether set or unset descriptor

@return KErrNone if operation was completed successfully, errorcode otherwise

*/

TInt CBulkOnlyTransportUsbcScLdd::SetupConfigurationDescriptor(TBool aUnset)

	{

	__FNLOG("CBulkOnlyTransportUsbcScLdd::SetupConfigurationDescriptor");

	TInt ret(KErrNone);

	if ((ret = iLdd.Open(0)) != KErrNone)

		return ret;

	TInt configDescriptorSize(0);

	iLdd.GetConfigurationDescriptorSize(configDescriptorSize);

	if (static_cast<TUint>(configDescriptorSize) != KUsbDescSize_Config)

		{

		return KErrCorrupt;

		}

	TBuf8<KUsbDescSize_Config> configDescriptor;

	ret = iLdd.GetConfigurationDescriptor(configDescriptor);

	if (ret != KErrNone)

		{

		return ret;

		}

	// I beleive that other fields setted up during LDD initialisation

	if (aUnset)

		{

		--configDescriptor[KUsbNumInterfacesOffset];

		}

	else

		{

		++configDescriptor[KUsbNumInterfacesOffset];

		}

	ret = iLdd.SetConfigurationDescriptor(configDescriptor);

	if (aUnset)

		{

		iLdd.Close();

		}

	return ret;

	}

/**

Set up interface descriptor

@return KErrNone if operation was completed successfully, errorcode otherwise

*/

TInt CBulkOnlyTransportUsbcScLdd::SetupInterfaceDescriptors()

	{

	__FNLOG("CBulkOnlyTransportUsbcScLdd::SetupInterfaceDescriptors");

	// Device caps

	TUsbDeviceCaps d_caps;

	TInt ret = iLdd.DeviceCaps(d_caps);

	if (ret != KErrNone)

		{

		return ret;

		}

	TInt totalEndpoints = d_caps().iTotalEndpoints;

	if (totalEndpoints  < KRequiredNumberOfEndpoints)

		{

		return KErrHardwareNotAvailable;

		}

	// Endpoint caps

	TUsbcEndpointData data[KUsbcMaxEndpoints];

	TPtr8 dataptr(reinterpret_cast<TUint8*>(data), sizeof(data), sizeof(data));

	ret = iLdd.EndpointCaps(dataptr);

	if (ret != KErrNone)

		{

		return ret;

		}

	// Set the active interface

	TUsbcScInterfaceInfoBuf ifc;

	TInt ep_found = 0;

	TBool foundBulkIN = EFalse;

	TBool foundBulkOUT = EFalse;

	for (TInt i = 0; i < totalEndpoints ; i++)

		{

		const TUsbcEndpointCaps* caps = &data[i].iCaps;

		const TInt maxPacketSize = caps->MaxPacketSize();

		if (!foundBulkIN &&

			(caps->iTypesAndDir & (KUsbEpTypeBulk | KUsbEpDirIn)) == (KUsbEpTypeBulk | KUsbEpDirIn))

			{

			// InEndpoint is going to be our TX (IN, write) endpoint

			ifc().iEndpointData[0].iType = KUsbEpTypeBulk;

			if((d_caps().iFeatureWord1 & KUsbDevCapsFeatureWord1_EndpointResourceAllocV2) == KUsbDevCapsFeatureWord1_EndpointResourceAllocV2)

				ifc().iEndpointData[0].iFeatureWord1  = KUsbcEndpointInfoFeatureWord1_DMA|KUsbcEndpointInfoFeatureWord1_DoubleBuffering;

			ifc().iEndpointData[0].iDir  = KUsbEpDirIn;

			ifc().iEndpointData[0].iSize = maxPacketSize;

			ifc().iEndpointData[0].iInterval_Hs = 0;

			ifc().iEndpointData[0].iBufferSize = KMaxScBufferSize;

			foundBulkIN = ETrue;

			if (++ep_found == KRequiredNumberOfEndpoints)

				{

				break;

				}

			continue;

			}

		if (!foundBulkOUT &&

			(caps->iTypesAndDir & (KUsbEpTypeBulk | KUsbEpDirOut)) == (KUsbEpTypeBulk | KUsbEpDirOut))

			{

			// OutEndpoint is going to be our RX (OUT, read) endpoint

			ifc().iEndpointData[1].iType = KUsbEpTypeBulk;

			if((d_caps().iFeatureWord1 & KUsbDevCapsFeatureWord1_EndpointResourceAllocV2) == KUsbDevCapsFeatureWord1_EndpointResourceAllocV2)

				ifc().iEndpointData[1].iFeatureWord1  = KUsbcEndpointInfoFeatureWord1_DMA|KUsbcEndpointInfoFeatureWord1_DoubleBuffering;

			ifc().iEndpointData[1].iDir  = KUsbEpDirOut;

			ifc().iEndpointData[1].iSize = maxPacketSize;

			ifc().iEndpointData[1].iInterval_Hs = 0;

			ifc().iEndpointData[1].iBufferSize = KMaxScBufferSize;

			ifc().iEndpointData[1].iReadSize = KMaxScReadSize;

			foundBulkOUT = ETrue;

			if (++ep_found == KRequiredNumberOfEndpoints)

				{

				break;

				}

			continue;

			}

		}

	if (ep_found != KRequiredNumberOfEndpoints)

		{

		return KErrHardwareNotAvailable;

		}

	_LIT16(string, "USB Mass Storage Interface");

	ifc().iString = const_cast<TDesC16*>(&string);

	ifc().iTotalEndpointsUsed = KRequiredNumberOfEndpoints;

	ifc().iClass.iClassNum    = 0x08;	// Mass Storage

	ifc().iClass.iSubClassNum = 0x06;	// SCSI Transparent Command Set

	ifc().iClass.iProtocolNum = 0x50;	// Bulk Only Transport

	if (d_caps().iHighSpeed)

		{

		// Tell the Protocol about it, because it might want to do some

		// optimizing too.

		iProtocol->ReportHighSpeedDevice();

		}

	if ((ret = iLdd.SetInterface(0, ifc)) == KErrNone)

		{

		return (iLdd.FinalizeInterface(iChunk));

		}

	return ret;

	}

void CBulkOnlyTransportUsbcScLdd::ReleaseInterface()

	{

	iLdd.ReleaseInterface(0);

	}

TInt CBulkOnlyTransportUsbcScLdd::StartControlInterface()

	{

	return iControlInterface->Start();

	}

void CBulkOnlyTransportUsbcScLdd::CancelControlInterface()

	{

	iControlInterface->Cancel();

	}

void CBulkOnlyTransportUsbcScLdd::ActivateDeviceStateNotifier()

	{

	iDeviceStateNotifier->Activate();

	}

void CBulkOnlyTransportUsbcScLdd::CancelDeviceStateNotifier()

	{

	iDeviceStateNotifier->Cancel();

	}

void CBulkOnlyTransportUsbcScLdd::CancelReadWriteRequests()

	{

	__FNLOG("CBulkOnlyTransportUsbcScLdd::CancelReadWriteRequests");

	TUsbcScChunkHeader chunkHeader(*iChunk);

	for (TInt i = 0; i < chunkHeader.iAltSettings->iNumOfAltSettings; i++)

		{

		TInt8* endpoint = (TInt8*) (chunkHeader.iAltSettings->iAltTableOffset[i] + (TInt) iChunk->Base());

		TInt numOfEps = chunkHeader.GetNumberOfEndpoints(i);

        __ASSERT_DEBUG(numOfEps >= 0, User::Invariant());

		for (TInt j = 1; j <= numOfEps; j++)

			{

			TUsbcScHdrEndpointRecord* endpointInf = (TUsbcScHdrEndpointRecord*) &(endpoint[j * chunkHeader.iAltSettings->iEpRecordSize]);

			if (endpointInf->Direction() == KUsbScHdrEpDirectionOut)

				{

				iLdd.ReadCancel(endpointInf->iBufferNo);

				}

			if (endpointInf->Direction() == KUsbScHdrEpDirectionIn)

				{

				iLdd.WriteCancel(endpointInf->iBufferNo);

				}

			}

		}

	}

void CBulkOnlyTransportUsbcScLdd::AllocateEndpointResources()

	{

	TUsbcScChunkHeader chunkHeader(*iChunk);

	for (TInt i = 0; i < chunkHeader.iAltSettings->iNumOfAltSettings; i++)

		{

		TInt8* endpoint = (TInt8*) (chunkHeader.iAltSettings->iAltTableOffset[i] + (TInt) iChunk->Base()); 

		for (TInt j = 1; j <= chunkHeader.GetNumberOfEndpoints(i); j++) 

			{

			TUsbcScHdrEndpointRecord* endpointInf = (TUsbcScHdrEndpointRecord*) &(endpoint[j * chunkHeader.iAltSettings->iEpRecordSize]);

			if (endpointInf->Direction() == KUsbScHdrEpDirectionOut)

				{

				iOutEndpoint = j;

				}

			if (endpointInf->Direction() == KUsbScHdrEpDirectionIn)

				{

				iInEndpoint = j;

				}

			}

		}

	TUsbDeviceCaps d_caps;

	TInt err;

	TInt ret = iLdd.DeviceCaps(d_caps);

	if (ret == KErrNone)

		{

		if((d_caps().iFeatureWord1 & KUsbDevCapsFeatureWord1_EndpointResourceAllocV2) != KUsbDevCapsFeatureWord1_EndpointResourceAllocV2)

			{		

			__PRINT(_L("CBulkOnlyTransportUsbcScLdd::Start  - Setting up DMA and double buffering\n"));

				// Set up DMA if possible (errors are non-critical)

			err = iLdd.AllocateEndpointResource(iOutEndpoint, EUsbcEndpointResourceDMA);

			if (err != KErrNone)

				{

				__PRINT1(_L("Set DMA on OUT endpoint failed with error code: %d"), err);

				}

			err = iLdd.AllocateEndpointResource(iInEndpoint, EUsbcEndpointResourceDMA);

			if (err != KErrNone)

				{

				__PRINT1(_L("Set DMA on IN endpoint failed with error code: %d"), err);

				}

				// Set up Double Buffering if possible (errors are non-critical)

			err = iLdd.AllocateEndpointResource(iOutEndpoint, EUsbcEndpointResourceDoubleBuffering);

			if (err != KErrNone)

				{

				__PRINT1(_L("Set Double Buffering on OUT endpoint failed with error code: %d"), err);

				}

			err = iLdd.AllocateEndpointResource(iInEndpoint, EUsbcEndpointResourceDoubleBuffering);

				if (err != KErrNone)

				{

				__PRINT1(_L("Set Double Buffering on IN endpoint failed with error code: %d"), err);

				}

			}

		}

	err = OpenEndpoints();

	}

TInt CBulkOnlyTransportUsbcScLdd::OpenEndpoints()

	{

	TInt res = iLdd.OpenEndpoint(iSCReadEndpointBuf, iOutEndpoint);

	if (res == KErrNone)

		{

		res = iLdd.OpenEndpoint(iSCWriteEndpointBuf, iInEndpoint);

		if (res == KErrNone)

			{

			iSCWriteEndpointBuf.GetInBufferRange((TAny*&)iDataPtr, iInBufferLength);

			res = iControlInterface->OpenEp0();

			}

		return res;

		}

	return res;

	}

TInt CBulkOnlyTransportUsbcScLdd::GetDeviceStatus(TUsbcDeviceState& deviceStatus)

	{

	return iLdd.DeviceStatus(deviceStatus);

	}

void CBulkOnlyTransportUsbcScLdd::FlushData()

	{

	// Intentionally Left Blank Do Nothing 

	}

/**

 * Read out rest data from OutEndpoint and discard them

 */

void CBulkOnlyTransportUsbcScLdd::ReadAndDiscardData(TInt /*aBytes*/)

	{

	__FNLOG("CBulkOnlyTransport::ReadAndDiscardData");

	TRequestStatus status;

	TInt r = KErrNone; // Lets assume there is no data

	do

		{

		iSCReadSize = 0;

		status = KErrNone;

		r = iSCReadEndpointBuf.TakeBuffer(iSCReadData,iSCReadSize,iReadZlp,status);

		iSCReadEndpointBuf.Expire();

		}

	while (r == KErrCompletion);

	if (r == KErrNone)

		{

		TRequestStatus* stat = &status;

		User::RequestComplete(stat, KErrNone);

		}

	}

/**

Called by the protocol to determine how many bytes of data are available in the read buffer.

@return The number of bytes available in the read buffer

*/

TInt CBulkOnlyTransportUsbcScLdd::BytesAvailable()

	{

	// Intentionally Left Blank Do Nothing 

	return 0;

	}

void CBulkOnlyTransportUsbcScLdd::StallEndpointAndWaitForClear()

	{

	__FNLOG("CBulkOnlyTransportUsbcScLdd::StallEndpointAndWaitForClear");

	// Now stall this endpoint

	__PRINT1(_L("Stalling endpoint %d"), iInEndpoint);

	TInt r = iLdd.HaltEndpoint(iInEndpoint);

	if (r != KErrNone)

		{

		__PRINT2(_L("Error: stalling ep %d failed: %d"), iInEndpoint, r);

		}

	TEndpointState ep_state;

	TInt i = 0;

	do

		{

		// Wait for 10ms before checking the ep status

		User::After(10000);

		iLdd.EndpointStatus(iInEndpoint, ep_state);

		if (++i >= 550)

			{

			// 5.5 secs should be enough (see 9.2.6.1 Request Processing Timing)

			__PRINT1(_L("Error: Checked for ep %d de-stall for 5.5s - giving up now"), iInEndpoint);

			// We can now only hope for a Reset Recovery

			return;

			}

		} while ((ep_state == EEndpointStateStalled) && iStarted);

	__PRINT2(_L("Checked for ep %d de-stall: %d time(s)"), iInEndpoint, i);

	}

/**

Read CBW data from the host and decode it.

*/

void CBulkOnlyTransportUsbcScLdd::ReadCBW()

	{

	__FNLOG("CBulkOnlyTransportUsbcScLdd::ReadCBW");

	if (IsActive())

		{

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

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

		return;

		}

	TInt r = KErrNone;

	do

		{

		r = ReadUsb();

		if ((r == KErrCompletion) && (iSCReadSize == KCbwLength))  

			{

			iCurrentState = EWaitForCBW;

			iStatus = KErrNone;

			DecodeCBW();

			iSCReadSize = 0;

			}

		else if (r == KErrNone)

			{

			iCurrentState = EWaitForCBW;

			SetActive();

			}

		else if ((r == KErrCompletion) && (iSCReadSize != KCbwLength))

			{

			ExpireData(iSCReadData);

			}

		}while ((r == KErrCompletion) && (!IsActive()));

	}

void CBulkOnlyTransportUsbcScLdd::ExpireData(TAny* aAddress)

	{

	if (aAddress)

		{

		iSCReadEndpointBuf.Expire(aAddress);

		}

	else

		{

		iSCReadEndpointBuf.Expire();

		}

	}

void CBulkOnlyTransportUsbcScLdd::ProcessCbwEvent()

	{

	ReadCBW();

	}

/**

Request data form the host for the protocol

@param aLength amount of data (in bytes) to be received from the host

*/

void CBulkOnlyTransportUsbcScLdd::ReadData(TUint /*aLength*/)

	{

	__FNLOG("CBulkOnlyTransportUsbcScLdd::ReadData");

	if (IsActive())

		{

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

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

		return;

		}

	TInt r = KErrNone;

	do

		{

		r = ReadUsb();

		iCurrentState = EReadingData;

		if (r == KErrCompletion)

			{

			iReadBufPtr.Set((TUint8*) iSCReadData, iSCReadSize, iSCReadSize);

			iStatus = KErrNone;

			ProcessDataFromHost();

			iSCReadSize = 0;

			}

		else if (r == KErrNone)

			{

			iSCReadSize = 0;

			SetActive();

			}

		}while ((r == KErrCompletion) && (!IsActive()));

	}

void CBulkOnlyTransportUsbcScLdd::ProcessDataFromHost()

	{

	TInt ret = KErrNone;

		{

		if (iReadSetUp)

			{

			ret = iProtocol->ReadComplete(KErrNone);

			}

#ifndef MSDC_MULTITHREADED

		ExpireData(iSCReadData);

#endif

		TUint deviceDataLength = iSCReadSize; // What was written to the disk // static_cast<TUint>(iReadBuf.Length());

		if(ret == KErrCompletion)

			{

			// The protocol has indicated with KErrCompletion that sufficient

			// data is available in the buffer to process the transfer immediately.

			//iDataResidue is initially set to host data length as we do not know how much data is there in the 'LDD transfer'. 

			//After a TakeBuffer call, iSCReadSize in updated and set to deviceDataLength

			iDataResidue -= deviceDataLength;

			}

		else

			{

			iDataResidue -= deviceDataLength;

			// The protocol has indicated that transfer is

			// complete, so send the CSW response to the host.

			iReadSetUp = EFalse;

			if (ret != KErrNone)

				{

				iCmdStatus = ECommandFailed;

				}

			if (iDataResidue)

				{

				__PRINT(_L("Discarding residue"));

				// we have to read as much data as available that host PC sends;

				// otherwise, bulk-out endpoint will need to keep sending NAK back.

				ReadAndDiscardData(iDataResidue); 

				}

			SendCSW(iCbwTag, iDataResidue, iCmdStatus);

			}

		}

	}

void CBulkOnlyTransportUsbcScLdd::WriteUsb(TRequestStatus& aStatus, TPtrC8& aDes, TUint aLength, TBool aZlpRequired)

	{

	TUint aOffset = (TUint) aDes.Ptr() - (TUint) iChunk->Base();

	iSCWriteEndpointBuf.WriteBuffer(aOffset, aLength, aZlpRequired, aStatus);

	}

void CBulkOnlyTransportUsbcScLdd::SetCbwPtr()

	{

	iCbwBufPtr.Set((TUint8*)iSCReadData, iSCReadSize);

	}

TPtr8& CBulkOnlyTransportUsbcScLdd::SetCommandBufPtr(TUint aLength)

	{

	TPtr8 writeBuf((TUint8*) iDataPtr, aLength);

	iCommandBufPtr.Set(writeBuf);

	return iCommandBufPtr;

	}

void CBulkOnlyTransportUsbcScLdd::SetReadDataBufPtr(TUint /*aLength*/)

	{

	// Do nothing for now 

	}

TPtr8& CBulkOnlyTransportUsbcScLdd::SetDataBufPtr()

	{

	TPtr8 writeBuf((TUint8*) iDataPtr, iInBufferLength);

	iDataBufPtr.Set(writeBuf);

	return iDataBufPtr;

	}

void CBulkOnlyTransportUsbcScLdd::SetPaddingBufPtr(TUint aLength)

	{

	TPtr8 writeBuf((TUint8*) iDataPtr, aLength, aLength);

	iPaddingBufPtr.Set(writeBuf);

	}

void CBulkOnlyTransportUsbcScLdd::SetCswBufPtr(TUint aLength)

	{

	TPtr8 writeBuf((TUint8*) iDataPtr, aLength, aLength);

	iCswBufPtr.Set(writeBuf);

	}

void CBulkOnlyTransportUsbcScLdd::ProcessReadingDataEvent()

	{

	ReadData();

	}

TInt CBulkOnlyTransportUsbcScLdd::ReadUsb(TUint /*aLength*/)

	{

	__FNLOG("CBulkOnlyTransportUsbcScLdd::ReadUSB");

	return iSCReadEndpointBuf.TakeBuffer(iSCReadData,iSCReadSize,iReadZlp,iStatus);

	}

void CBulkOnlyTransportUsbcScLdd::DiscardData(TUint aLength)

	{

	TUint c = 0;

	TRequestStatus status;

	TInt r = KErrNone;

	while (c < aLength)

		{

		iSCReadSize = 0;

		status = KErrNone;

		r = iSCReadEndpointBuf.TakeBuffer(iSCReadData,iSCReadSize,iReadZlp,status);

		c += iSCReadSize;

		if (r == KErrNone)

			User::WaitForRequest(status);

		if (r == KErrCompletion)

			{

			iSCReadEndpointBuf.Expire();

			}

		iSCReadSize = 0;

		}

	}

void CBulkOnlyTransportUsbcScLdd::WriteToClient(TUint aLength)

	{

	TUint c = 0;

	TRequestStatus status;

	TInt r = KErrNone;

	while (c < aLength)

		{

		iSCReadSize = 0;

		status = KErrNone;

		r = iSCReadEndpointBuf.TakeBuffer(iSCReadData,iSCReadSize,iReadZlp,status);

		c += iSCReadSize;

		iProtocol->ReadComplete(KErrGeneral);

		if (r == KErrNone)

			User::WaitForRequest(status);

		if (r == KErrCompletion)

			{

			iSCReadEndpointBuf.Expire();

			}

		iSCReadSize = 0;

		}

	}

#ifdef MSDC_MULTITHREADED

void CBulkOnlyTransportUsbcScLdd::GetBufferPointers(TPtr8& aDes1, TPtr8& aDes2)

	{

	//for DB

	TUint length = (TUint) (iInBufferLength - KCswBufferSize) / 2;

	TUint8* start = (TUint8*) (iDataPtr) + KCswBufferSize ; // 'first' buffer

	aDes1.Set(start, length, length);

	start = (TUint8*) (iDataPtr) + KCswBufferSize + length; // 'second' buffer

	aDes2.Set(start, length, length);

	}

#endif

void CBulkOnlyTransportUsbcScLdd::Activate(TRequestStatus& aStatus, TUint& aDeviceState)

    {

	iLdd.AlternateDeviceStatusNotify(aStatus, aDeviceState);

    }

void CBulkOnlyTransportUsbcScLdd::Cancel()

    {

	iLdd.AlternateDeviceStatusNotifyCancel();

    }