// Copyright (c) 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 <e32base.h>

#include <d32usbc.h>

#include "mstypes.h"

#include "msctypes.h"

#include "usbmsclientpanic.h"

#include "botmsctypes.h"

#include "testman.h"

#include "botmscserver.h"

#include "mserverprotocol.h"

#include "mdevicetransport.h"

#include "mstypes.h"

#include "botcontrolinterface.h"

#include "debug.h"

#include "msdebug.h"

#include "cusbmassstorageserver.h"

#include "cusbmassstoragecontroller.h"

#include "drivemanager.h"

#include "cbulkonlytransport.h"

#define KInEndpoint EEndpoint1

#define KOutEndpoint EEndpoint2

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

/**

Create CBulkOnlyTransport object

@param aNumDrives - The number of drives available for MS

@param aController - reference to the parent

@return pointer to newly created object

*/

CBulkOnlyTransport* CBulkOnlyTransport::NewL(TInt aNumDrives,

                                             CUsbMassStorageController& aController)

	{

    __MSFNSLOG

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

		{

		User::Leave(KErrArgument);

		}

	CBulkOnlyTransport* self = new(ELeave) CBulkOnlyTransport(aNumDrives, aController);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

#ifdef MSDC_TESTMODE

CBulkOnlyTransport* CBulkOnlyTransport::NewL(TInt aNumDrives,

                                             CUsbMassStorageController& aController,

                                             TTestParser* aTestParser)

	{

    __MSFNSLOG

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

		{

		User::Leave(KErrArgument);

		}

	CBulkOnlyTransport* self = new(ELeave) CBulkOnlyTransport(aNumDrives,

                                                              aController,

                                                              aTestParser);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

#endif

/**

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)

	{

    __MSFNLOG

	}

#ifdef MSDC_TESTMODE

CBulkOnlyTransport::CBulkOnlyTransport(TInt aNumDrives,

                                       CUsbMassStorageController& aController,

                                       TTestParser* aTestParser)

:   CActive(EPriorityStandard),

	iMaxLun(aNumDrives-1),

	iController(aController),

	iStallAllowed(ETrue),

    iTestParser(aTestParser)

	{

    __MSFNLOG

	}

#endif

/**

Constructs the CBulkOnlyTranspor object

*/

void CBulkOnlyTransport::ConstructL()

	{

    __MSFNLOG

	iBotControlInterface = CBotControlInterface::NewL(*this);

	iDeviceStateNotifier = CActiveDeviceStateNotifier::NewL(*this);

	CActiveScheduler::Add(this);

	}

/**

Destructor

*/

CBulkOnlyTransport::~CBulkOnlyTransport()

	{

    __MSFNLOG

	if (iInterfaceConfigured)

		{

		Stop();

		}

	delete iBotControlInterface;

	delete iDeviceStateNotifier;

	}

/**

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 CBulkOnlyTransport::SetupConfigurationDescriptor(TBool aUnset)

	{

    __MSFNLOG

	TInt ret(KErrNone);

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

	return ret;

	}

/**

Set up interface descriptor

@return KErrNone if operation was completed successfully, errorcode otherwise

*/

TInt CBulkOnlyTransport::SetupInterfaceDescriptors()

	{

    __MSFNLOG

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

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

			{

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

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

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

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

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

			foundBulkIN = ETrue;

			if (++ep_found == KRequiredNumberOfEndpoints)

				{

				break;

				}

			continue;

			}

		if (!foundBulkOUT &&

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

			{

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

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

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

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

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

			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

	TUint bandwidth_priority = (EUsbcBandwidthOUTDefault | EUsbcBandwidthINDefault);

	if (d_caps().iHighSpeed)

		{

		// If this device supports USB High-speed, then we request 64KB buffers

		// (otherwise the default 4KB ones will do).

		bandwidth_priority = (EUsbcBandwidthOUTPlus2 | EUsbcBandwidthINPlus2);

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

		// optimizing too.

		iProtocol->ReportHighSpeedDevice();

		}

	ret = iLdd.SetInterface(0, ifc, bandwidth_priority);

	return ret;

	}

/**

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

@param aData reference to the data buffer.

*/

void CBulkOnlyTransport::SetupDataOut(TPtr8& aData)

    {

    __MSFNLOG

    iDataTransferMan.SetModeDataOut(aData);

    }

/**

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::SetupDataIn(TPtrC8& aData)

	{

    iDataTransferMan.SetModeDataIn(aData);

	}

TInt CBulkOnlyTransport::Start()

	{

    __MSFNLOG

	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 = iLdd.Open(0))					!= KErrNone ||

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

		(err = SetupInterfaceDescriptors())		!= KErrNone )

		{

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

		return err;

		}

	iDeviceStateNotifier->Activate();  // activate notifier wich will wait until USB became configured

	TUsbcDeviceState deviceStatus = EUsbcDeviceStateDefault;

	err = iLdd.DeviceStatus(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();

		}

	iInterfaceConfigured = ETrue;

	return err;

	}

TInt CBulkOnlyTransport::HwStart(TBool aDiscard)

	{

    __MSFNLOG

    TInt lun = MaxLun();

    do

        {

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

        }

    while(--lun >= 0);

	TInt res = iBotControlInterface->Start() ;

	iCurrentState = ENone;

    iDataTransferMan.Init();

	iStarted = ETrue;

		{

		}

    if (aDiscard)

		{

		TInt bytes;

		const TInt err = iLdd.QueryReceiveBuffer(KOutEndpoint, bytes);

		if (err != KErrNone || bytes <= 0)

			{

			__PRINT1(_L("Error: err=%d bytes=%d"), bytes);

			}

		else

			{

			__PRINT1(_L("RxBuffer has %d bytes"), bytes);

			FlushDataOut(bytes);

			}

		}

	ClientReadCbw();

	return res;

	}

void CBulkOnlyTransport::HwStop()

	{

    __MSFNLOG

	if (iStarted)

		{

        iController.DriveManager().Disconnect();

		Cancel();

		iBotControlInterface->Cancel();

		iProtocol->Cancel();

		iStarted = EFalse;

		}

	}

void CBulkOnlyTransport::HwSuspend()

	{

    __MSFNLOG

    iController.DriveManager().Disconnect();

	}

void CBulkOnlyTransport::HwResume()

	{

    __MSFNLOG

    iController.DriveManager().Connect();

	}

/**

Stops the Bulk Only Transport

*/

TInt CBulkOnlyTransport::Stop()

	{

    __MSFNLOG

	iBotControlInterface->Cancel();

	iDeviceStateNotifier->Cancel();

	Cancel();

	if  (iInterfaceConfigured)

		{

		iLdd.ReleaseInterface(0);

		SetupConfigurationDescriptor(ETrue);

		iLdd.Close();

		}

	iCurrentState = ENone;

	iInterfaceConfigured = EFalse;

	return KErrNone;

	}

/**

Read aLength bytes of data from the host into the read buffer.

@param aLength The number of bytes to read from the host.

*/

void CBulkOnlyTransport::ClientReadCbw()

	{

    __MSFNLOG

	if (IsActive())

		{

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

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

		return;

		}

    ReadCbw();

    }

void CBulkOnlyTransport::ReadCbw()

	{

    __MSFNLOG

	iCbwBuf.SetMax();

	iLdd.ReadUntilShort(iStatus, KOutEndpoint, iCbwBuf, iCbwBuf.Length());

	iCurrentState = EWaitForCBW;

	SetActive();

	}

void CBulkOnlyTransport::DoCancel()

	{

    __MSFNLOG

	iLdd.WriteCancel(KInEndpoint);

	iLdd.ReadCancel(KOutEndpoint);

	}

void CBulkOnlyTransport::Activate(TInt aReason)

    {

    __MSFNLOG

    SetActive();

    TRequestStatus* r = &iStatus;

    User::RequestComplete(r, aReason);

    }

void CBulkOnlyTransport::RunL()

	{

    __MSFNLOG

	if (iStatus != KErrNone)

		{

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

		SetPermError(); //halt endpoints for reset recovery

		return;

		}

	switch (iCurrentState)

		{