/*

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

#include "massstoragedebug.h"

#include "cusbmassstorageserver.h"

#define InEndpoint EEndpoint1

#define OutEndpoint EEndpoint2

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

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

/**

Called by CBulkOnlyTransportUsbcLdd to create an instance of CControlInterfaceUsbcLdd

@param aParent reference to the CBulkOnlyTransportUsbcLdd

*/

CControlInterfaceUsbcLdd* CControlInterfaceUsbcLdd::NewL(CBulkOnlyTransportUsbcLdd& aParent)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CActiveScheduler::Add(self);

	CleanupStack::Pop();

	return self;

	}

void CControlInterfaceUsbcLdd::ConstructL()

	{

	}

/**

c'tor

@param aParent reference to the CBulkOnlyTransportUsbcLdd

*/

CControlInterfaceUsbcLdd::CControlInterfaceUsbcLdd(CBulkOnlyTransportUsbcLdd& aParent)

	:CActive(EPriorityStandard),

	 iParent(aParent),

	 iCurrentState(ENone)

	{

	}

/**

d'tor

*/

CControlInterfaceUsbcLdd::~CControlInterfaceUsbcLdd()

	{

	__FNLOG("CControlInterfaceUsbcLdd::~CControlInterfaceUsbcLdd ");

	Cancel();

	}

/**

Called by CBulkOnlyTransport HwStart to start control interface

*/

TInt CControlInterfaceUsbcLdd::Start()

	{

	__FNLOG("CControlInterfaceUsbcLdd::Start ");

	TInt res = ReadEp0Data();

	return (res);

	}

/**

Called by desctructor of CBulkOnlyTransportUsbcLdd to stop control interface

*/

void CControlInterfaceUsbcLdd::Stop()

	{

	__FNLOG("CControlInterfaceUsbcLdd::Stop ");

	if (!IsActive())

		{

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

		return;

		}

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

	iCurrentState = ENone;

	Cancel();

	}

/**

Cancel outstanding request (if any)

*/

void CControlInterfaceUsbcLdd::DoCancel()

	{

	__FNLOG("CControlInterfaceUsbcLdd::DoCancel ");

	switch(iCurrentState)

		{

		case EReadEp0Data:

			iParent.Ldd().ReadCancel(EEndpoint0);

			break;

		case ESendMaxLun:

			iParent.Ldd().WriteCancel(EEndpoint0);

			break;

		default:

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

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

		}

	}

/**

Implement CControlInterfaceUsbcLdd state machine

*/

void CControlInterfaceUsbcLdd::RunL()

	{

	__FNLOG("CControlInterfaceUsbcLdd::RunL ");

	if (iStatus != KErrNone)

		{

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

		//read EP0  again

		ReadEp0Data();

		return;

		}

	switch (iCurrentState)

		{

		case ESendMaxLun:

			ReadEp0Data();

			break;

		case EReadEp0Data:

			DecodeEp0Data();

			break;

		default:

			__PRINT(_L("  error: (Shouldn't end up here...)\n"));

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

			break;

		}

	return;

	}

/**

Post a read request to EEndpoint0 to read request header

*/

TInt CControlInterfaceUsbcLdd::ReadEp0Data()

	{

	__FNLOG("CControlInterfaceUsbcLdd::ReadEp0Data ");

	if (IsActive())

		{

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

		return KErrServerBusy;

		}

	iParent.Ldd().Read(iStatus, EEndpoint0, iData, KRequestHdrSize);

	iCurrentState = EReadEp0Data;

	SetActive();

	return KErrNone;

	}

/**

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

*/

void CControlInterfaceUsbcLdd::DecodeEp0Data()

	{

	__FNLOG("CControlInterfaceUsbcLdd::DecodeEp0Data ");

	if (IsActive())

		{

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

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

		return;

		}

	TInt err = iRequestHeader.Decode(iData);

	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;

                }

			iData.FillZ(1);  //Return only 1 byte to host

			iData[0] = static_cast<TUint8>(iParent.MaxLun());	// Supported Units

			iParent.Ldd().Write(iStatus, EEndpoint0, iData, 1);

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

//

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

	:CBulkOnlyTransport(aNumDrives, aController),

	 iSwap(ETrue)

	{

	__FNLOG("CBulkOnlyTransportUsbcLdd::CBulkOnlyTransportUsbcLdd");

	}

/**

Constructs the CBulkOnlyTransportUsbcLdd object

*/

void CBulkOnlyTransportUsbcLdd::ConstructL()

	{

	__FNLOG("CBulkOnlyTransportUsbcLdd::ConstructL()");

	iControlInterface = CControlInterfaceUsbcLdd::NewL(*this);

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

	CActiveScheduler::Add(this);

	}

CBulkOnlyTransportUsbcLdd::~CBulkOnlyTransportUsbcLdd()

	{

	__FNLOG("CBulkOnlyTransportUsbcLdd::~CBulkOnlyTransportUsbcLdd");

	if (iInterfaceConfigured)

		{

		delete iControlInterface ;

		delete iDeviceStateNotifier;

		}

	}	

RDevUsbcClient& CBulkOnlyTransportUsbcLdd::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 CBulkOnlyTransportUsbcLdd::SetupConfigurationDescriptor(TBool aUnset)

	{

	__FNLOG("CBulkOnlyTransportUsbcLdd::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 CBulkOnlyTransportUsbcLdd::SetupInterfaceDescriptors()

	{

	__FNLOG("CBulkOnlyTransportUsbcLdd::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

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

			{

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

			{

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

	}

void CBulkOnlyTransportUsbcLdd::ReleaseInterface()

	{

	iLdd.ReleaseInterface(0);

	}

TInt CBulkOnlyTransportUsbcLdd::StartControlInterface()

	{

	return iControlInterface->Start();

	}

void CBulkOnlyTransportUsbcLdd::CancelControlInterface()

	{

	iControlInterface->Cancel();

	}

void CBulkOnlyTransportUsbcLdd::ActivateDeviceStateNotifier()

	{

	iDeviceStateNotifier->Activate();

	}

void CBulkOnlyTransportUsbcLdd::CancelDeviceStateNotifier()

	{

	iDeviceStateNotifier->Cancel();

	}

void CBulkOnlyTransportUsbcLdd::CancelReadWriteRequests()

	{

	__FNLOG("CBulkOnlyTransportUsbcLdd::CancelReadWriteRequests");

	iLdd.WriteCancel(InEndpoint);

	iLdd.ReadCancel(OutEndpoint);

	}

void CBulkOnlyTransportUsbcLdd::AllocateEndpointResources()

	{

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

	TInt err = iLdd.AllocateEndpointResource(OutEndpoint, EUsbcEndpointResourceDMA);

	if (err != KErrNone)

		{

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

		}

	err = iLdd.AllocateEndpointResource(InEndpoint, 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(OutEndpoint, EUsbcEndpointResourceDoubleBuffering);

	if (err != KErrNone)

		{

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

		}

	err = iLdd.AllocateEndpointResource(InEndpoint, EUsbcEndpointResourceDoubleBuffering);

	if (err != KErrNone)

		{

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

		}

	}

TInt CBulkOnlyTransportUsbcLdd::GetDeviceStatus(TUsbcDeviceState& deviceStatus)

	{

	return iLdd.DeviceStatus(deviceStatus);

	}

void CBulkOnlyTransportUsbcLdd::FlushData()

	{

	TInt bytes;

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

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

		{

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

		}

	else

		{