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

 */

#include "bulkonlytransport.h"

#include "mscfileserver.h"

#include "usbmscfileshared.h"

#include "debug.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. 

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

LOCAL_D const TInt KCswLength = 13;

LOCAL_D const TInt KUsbNumInterfacesOffset = 4;

/**

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

        {

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

        return KErrGeneral;

        }

    // Decode as SPEC 1.3.3

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

    TRACE_INFO((_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) ? ETrue : EFalse;

    }

//

/**

 Called by CBulkOnlyTransport to create an instance of CControlInterface

 @param aParent reference to the CBulkOnlyTransport

 */

CControlInterface* CControlInterface::NewL(CBulkOnlyTransport& aParent)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CActiveScheduler::Add(self);

    CleanupStack::Pop();

    return self;

    }

void CControlInterface::ConstructL()

    {

    }

/**

 c'tor

 @param aParent reference to the CBulkOnlyTransport

 */

CControlInterface::CControlInterface(CBulkOnlyTransport& aParent) :

	CActive(EPriorityStandard),

	iParent(aParent),

	iCurrentState(ENone)

    {

    }

/**

 d'tor

 */

CControlInterface::~CControlInterface()

    {

    TRACE_FUNC

	Cancel();

    }

/**

 Called by  CBulkOnlyTransportStart to start control interface

 */

TInt CControlInterface::Start()

    {

    TRACE_FUNC

    TInt res = ReadEp0Data();

    return (res);

    }

/**

 Called by CBulkOnlyTransportStart to stop control interface

 */

void CControlInterface::Stop()

    {

    TRACE_FUNC

    // Don't need to be any thing if we're not in active state

    if (!IsActive())

        {

        TRACE_INFO((_L("Not active")))

        return;

        }

    TRACE_INFO((_L("Stopping...")))

    // Stop by cancel

    Cancel();

    iCurrentState = ENone;

    }

/**

 Cancel outstanding request (if any)

 */

void CControlInterface::DoCancel()

    {

    TRACE_FUNC

    switch(iCurrentState)

        {

        case EReadEp0Data:

        iParent.Ldd().ReadCancel(EEndpoint0);

        break;

        case ESendMaxLun:

        iParent.Ldd().WriteCancel(EEndpoint0);

        break;

        default:

        TRACE_ERROR((_L("\nWrong state !")))

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

        }

    }

/**

 Implement CControlInterface state machine

 */

void CControlInterface::RunL()

    {

    TRACE_FUNC

    if (iStatus != KErrNone)

        {

        TRACE_ERROR(( _L( "Error %d in RunL" ), iStatus.Int() ))

        //read EP0  again 

        ReadEp0Data();

        return;

        }

    switch (iCurrentState)

        {

        case ESendMaxLun:

            ReadEp0Data();

            break;

        case EReadEp0Data:

            DecodeEp0Data();

            break;

        default:

            TRACE_ERROR(( _L( "error: (Shouldn't end up here...)" ) ))

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

            break;

        }

    return;

    }

/**

 Post a read request to EEndpoint0 to read request header

 */

TInt CControlInterface::ReadEp0Data()

    {

    TRACE_FUNC

    if ( IsActive() )

        {

        TRACE_ERROR(( _L( "Still active" ) ))

        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 CControlInterface::DecodeEp0Data()

    {

    TRACE_FUNC

    if ( IsActive() )

        {

        TRACE_ERROR(( _L( "Still active" ) ))

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

        return;

        }

    TInt err = iRequestHeader.Decode(iData);

    if (err != KErrNone)

        {

        TRACE_WARNING((_L("Decode header error : err=%d"), err))

        return;

        }

    switch(iRequestHeader.iRequest)

        {

        // GET MAX LUN (0xFE)

        case TUsbRequestHdr::EReqGetMaxLun:

            {

            TRACE_INFO((_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)

                {

                TRACE_ERROR((_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:

            {

            TRACE_INFO((_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)

                {

                TRACE_ERROR((_L("MSC Reset command packet check error")))

                iParent.Ldd().EndpointZeroRequestError();

                break;

                }

            iParent.HwStop();

            iParent.Controller().Reset();

            iParent.HwStart(ETrue);

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

            TRACE_INFO((_L("SendEp0StatusPacket: err=%d"), err))

            return;

            }

        // Unknown?

        default:

            {

            TRACE_ERROR((_L("DecodeEp0Data : Unknown Request")))

            }

        }

    ReadEp0Data(); //try to get another request 

    }

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

/**

 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,CMscFileController& aController)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/**

 c'tor 

 @param aNumDrives - The number of drives available for MS

 @param aController - reference to the parent

 */

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

	CActive(EPriorityStandard),

	iMaxLun(aNumDrives-1),

	iController(aController),

	iReadBuf(NULL,0),

	iWriteBuf(NULL,0),

	iStallAllowed(ETrue)

    {

    }

/**

 Constructs the CBulkOnlyTranspor object

 */

void CBulkOnlyTransport::ConstructL()

    {

    TRACE_FUNC

    iControlInterface = CControlInterface::NewL(*this);

    iDeviceStateNotifier = CActiveDeviceStateNotifier::NewL(*this);

    CActiveScheduler::Add(this);

    }

/**

 Destructor

 */

CBulkOnlyTransport::~CBulkOnlyTransport()

    {

    TRACE_FUNC

    if (iInterfaceConfigured)

        {

        Stop();

        }

    delete iControlInterface;

    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)

    {

    TRACE_FUNC

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

    {

    TRACE_FUNC

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

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

            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;

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

            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::SetupReadData(TPtr8& aData)

    {

    TRACE_FUNC

    TRACE_INFO((_L("Length = %d  (bytes)"), aData.Length()))

    iReadBuf.Set(aData);

    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)

    {

    TRACE_FUNC

    TRACE_INFO((_L("Length = %d  (bytes)"), aData.Length()))

    iWriteBuf.Set(aData);

    iWriteSetUp = ETrue;

    }

TInt CBulkOnlyTransport::Start()

    {

    TRACE_FUNC_ENTRY