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

//

#include <e32base.h>

#include <f32file.h>

#include <e32property.h>

#include "mstypes.h"

#include "msctypes.h"

#include "usbmsshared.h"

#include "drivemanager.h"

#include "drivepublisher.h"

#include "tscsiserverreq.h"

#include "tscsiservercmds.h"

#include "mserverprotocol.h"

#include "mdevicetransport.h"

#include "testman.h"

#include "cscsiserverprotocol.h"

#include "debug.h"

#include "msdebug.h"

TMediaWriteMan::TMediaWriteMan()

:   iActive(EFalse),

    iOffset(0),

	iMediaWriteSize(KDefaultMediaWriteSize)

    {

    }

void TMediaWriteMan::ReportHighSpeedDevice()

	{

    __MSFNLOG

	iMediaWriteSize = KHsMediaWriteSize;

	__PRINT1(_L("HS Device reported: SCSI will use %d bytes disk write size"), iMediaWriteSize);

	}

TInt64 TMediaWriteMan::Start(TUint32 aLba, TUint32 aLength, TUint32 aBlockSize)

    {

    iActive = ETrue;

    iOffset = static_cast<TInt64>(aLba) * aBlockSize;

    iBytesRemain = aLength * aBlockSize;

	TInt64 theEnd = iOffset + iBytesRemain;

    return theEnd;

    }

TUint32 TMediaWriteMan::NextPacket()

    {

    iActive = ETrue;

    return (iBytesRemain < iMediaWriteSize) ? iBytesRemain : iMediaWriteSize;

    }

void TMediaWriteMan::Reset()

    {

    iActive = EFalse;

    iOffset = 0;

    }

void TMediaWriteMan::SetOffset(const TInt64& aOffset, TUint aLength)

    {

    iOffset = aOffset + aLength;

    iBytesRemain -= aLength;

    }

TUint32 TMediaWriteMan::GetPacketLength() const

    {

    // KMaxBufSize or the MediaWriteSize, whichever is smallest.

	TUint32 thisLength = (iBytesRemain > KMaxBufSize) ? KMaxBufSize : iBytesRemain;

	thisLength = (thisLength > iMediaWriteSize) ? iMediaWriteSize : thisLength;

    return thisLength;

    }

/**

Creates the CScsiProtocol object.  Called during controller initialisation.

@param aDriveManager reference to the drive manager object

*/

CScsiServerProtocol* CScsiServerProtocol::NewL(CDriveManager& aDriveManager)

	{

    __MSFNSLOG

	CScsiServerProtocol* self = new (ELeave) CScsiServerProtocol(aDriveManager);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

#ifdef MSDC_TESTMODE

CScsiServerProtocol* CScsiServerProtocol::NewL(CDriveManager& aDriveManager, TTestParser* aTestParser)

	{

    __MSFNSLOG

	CScsiServerProtocol* self = new (ELeave) CScsiServerProtocol(aDriveManager, aTestParser);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

#endif

/**

c'tor

@param aDriveManager reference to the drive manager object

*/

CScsiServerProtocol::CScsiServerProtocol(CDriveManager& aDriveManager)

:   iDriveManager(aDriveManager)

	{

    __MSFNLOG

	iWriteTransferPublisher = CUsbWriteTransferPublisher::NewL(iBytesWritten);

	iReadTransferPublisher = CUsbReadTransferPublisher::NewL(iBytesRead);

	for (TUint i = 0; i < KUsbMsMaxDrives; i++)

		{

		iBytesRead[i] = 0;

		iBytesWritten[i] = 0;

		}

	}

#ifdef MSDC_TESTMODE

CScsiServerProtocol::CScsiServerProtocol(CDriveManager& aDriveManager, TTestParser* aTestParser)

:   iDriveManager(aDriveManager),

    iTestParser(aTestParser)

	{

    __MSFNLOG

	iWriteTransferPublisher = CUsbWriteTransferPublisher::NewL(iBytesWritten);

	iReadTransferPublisher = CUsbReadTransferPublisher::NewL(iBytesRead);

	for (TUint i = 0; i < KUsbMsMaxDrives; i++)

		{

		iBytesRead[i] = 0;

		iBytesWritten[i] = 0;

		}

	}

#endif

CScsiServerProtocol::~CScsiServerProtocol()

	{

    __MSFNLOG

    iDataBuf.Close();

	delete iWriteTransferPublisher;

	delete iReadTransferPublisher;

	}

void CScsiServerProtocol::ConstructL()

	{

    __MSFNLOG

	}

/**

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

@param aTransport pointer to the transport object

*/

void CScsiServerProtocol::RegisterTransport(MDeviceTransport* aTransport)

	{

    __MSFNLOG

	iTransport = aTransport;

	}

/**

Called by the Transport when it detects that the USB device is either running

at High Speed or is at least capable of HS operation. The Protocol can use this

information (for instance) to select the optimal write block size to use.

This function is preferably called before actual MS data transfer operation

starts, and usually only once.

*/

void CScsiServerProtocol::ReportHighSpeedDevice()

	{

    __MSFNLOG

    iMediaWriteMan.ReportHighSpeedDevice();

	}

void CScsiServerProtocol::SetParameters(const TMassStorageConfig& aConfig)

	{

    __MSFNLOG

	iConfig = aConfig;

	}

/**

Called by the transport layer when a packet is available for decoding.

If an error occurs, the sense code is updated and EFalse is returned.

@param aData

@return  ETrue if command was decoded and executed successfully

*/

TBool CScsiServerProtocol::DecodePacket(TPtrC8& aData, TUint8 aLun)

	{

    __MSFNLOG

    TScsiServerReq* cdb = NULL;

    TRAPD(err, cdb = cdb->CreateL(static_cast<TScsiServerReq::TOperationCode>(aData[0]), aData));

    TBool decodeGood = EFalse;

    if (err == KErrNotSupported)

    	iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidCmdCode);

	else if (err != KErrNone)

		iSenseInfo.SetSense(TSenseInfo::EAbortedCommand, TSenseInfo::EInsufficientRes);

    else if (cdb->iNaca) // Check the CONTROL byte

		iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);

    else if (cdb->iLink)

        iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);

    else

        {

        TScsiServerReq::TOperationCode operationCode = cdb->iOperationCode;

        if (aLun > iDriveManager.MaxLun())

            {

            __PRINT(_L("No drive available\n"));

            iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::ELuNotSupported);

            }

        else

            {

            iLun = aLun;

            if (operationCode != TScsiServerReq::ERequestSense)

                {

                iSenseInfo.SetSense(TSenseInfo::ENoSense);

                }

            switch (operationCode)

                {

            case TScsiServerReq::ETestUnitReady:

                HandleUnitReady();

                break;

            case TScsiServerReq::ERequestSense:

                HandleRequestSense(*cdb);

                break;

            case TScsiServerReq::EInquiry:

                HandleInquiry(*cdb);

                break;

            case TScsiServerReq::EModeSense6:

                HandleModeSense6(*cdb);

                break;

            case TScsiServerReq::EStartStopUnit:

                HandleStartStopUnit(*cdb);

                break;

            case TScsiServerReq::EPreventMediaRemoval:

                HandlePreventMediaRemoval(*cdb);

                break;

            case TScsiServerReq::EReadCapacity10:

                HandleReadCapacity10(*cdb);

                break;

            case TScsiServerReq::ERead10:

                HandleRead10(*cdb);

                break;

            case TScsiServerReq::EWrite10:

                HandleWrite10(*cdb);

                break;

            case TScsiServerReq::EReadFormatCapacities:

                HandleReadFormatCapacities(*cdb);

                break;

            default:

                iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidCmdCode);

                break;

                }

            }

        __PRINT1(_L("DecodePacket result = %d"), iSenseInfo.SenseOk());

    	decodeGood = iSenseInfo.SenseOk();

        }

    delete cdb;

    return decodeGood;

	}

/**

Checks if drive ready

@param aLun Logic unit number

@return pointer to drive correspondent to LUN if drive mounted and ready, NULL otherwise

*/

CMassStorageDrive* CScsiServerProtocol::GetCheckDrive()

	{

    __MSFNLOG

#ifdef MSDC_TESTMODE

    if (iTestParser && iTestParser->SenseError() != TTestParser::ETestSenseErrorNoSense)

        {

        switch (iTestParser->SenseError())

            {

            case TTestParser::ETestSenseErrorMediaNotPresent:

                __TESTMODEPRINT("Set SENSE ERROR(ENotReady, EMediaNotPresent)");

                iSenseInfo.SetSense(TSenseInfo::ENotReady,

                                    TSenseInfo::EMediaNotPresent);

                break;

            case TTestParser::ETestSenseErrorUnitAttention:

            default:

                __TESTMODEPRINT("Set SENSE ERROR(EUnitAttention, ENotReadyToReadyChange)");

                iSenseInfo.SetSense(TSenseInfo::EUnitAttention,

                                    TSenseInfo::ENotReadyToReadyChange);

                break;

            }

        iTestParser->ClrSenseError();

        return NULL;

        }

#endif

	CMassStorageDrive* drive = iDriveManager.Drive(iLun);

	CMassStorageDrive::TMountState mountState = drive->MountState();

	if (mountState == CMassStorageDrive::EDisconnected || mountState == CMassStorageDrive::EConnecting)

		{

		__PRINT(_L("Drive disconnected\n"));

		iSenseInfo.SetSense(TSenseInfo::ENotReady,

							TSenseInfo::EMediaNotPresent);

		return NULL;

		}

	TLocalDriveRef::TDriveState state = drive->CheckDriveState();

	if (state == TLocalDriveRef::EMediaNotPresent || state == TLocalDriveRef::ELocked)

		{

		__PRINT1(_L("Media not present or locked. (state =0x%X)\n"),state);

		iSenseInfo.SetSense(TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);

		return NULL;

		}

	if (drive->IsMediaChanged(ETrue))  //reset "media changed" status

		{

		__PRINT(_L("Media was changed\n"));

		// SAM-2 Section 5.9.5 Unit Attention Condition

		iSenseInfo.SetSense(TSenseInfo::EUnitAttention, TSenseInfo::ENotReadyToReadyChange);

		iDriveManager.Connect(iLun);   //publish event to USB app

		return NULL;

		}

	if (mountState == CMassStorageDrive::EDisconnecting)

		{

		__PRINT(_L("Drive disconnecting\n"));

		iSenseInfo.SetSense(TSenseInfo::ENotReady,

							TSenseInfo::EMediaNotPresent);

		return NULL;

		}

	return drive;

	}

/**

Command Parser for the UNIT READY command (0x00)

@param aLun Logic unit number

@return ETrue if successful,

*/

TBool CScsiServerProtocol::HandleUnitReady()

	{

    __MSFNLOG

	return GetCheckDrive() ? ETrue : EFalse;

	}

/**

Command Parser for the REQUEST SENSE command (0x03)

@return ETrue if successful,

*/

TBool CScsiServerProtocol::HandleRequestSense(const TScsiServerReq& aRequest)

	{

    __MSFNLOG

    const TScsiServerRequestSenseReq request = static_cast<const TScsiServerRequestSenseReq&>(aRequest);

	__PRINT1(_L("length = %d\n"), request.iAllocationLength);

    TScsiServerRequestSenseResp requestSense;

    requestSense.iAllocationLength = request.iAllocationLength;

    requestSense.SetResponseCode(TScsiServerRequestSenseResp::ECurrentErrors);

    requestSense.iSensePtr = &iSenseInfo;

    requestSense.Encode(iCommandBuf);

	__PRINT4(_L("Response=0x%x Sense=0x%x, Additional=0x%x, Qualifier=0x%x\n"),

				iCommandBuf[0], iCommandBuf[02], iCommandBuf[12], iCommandBuf[13]);

	TPtrC8 writeBuf = iCommandBuf.Left(request.iAllocationLength);

	iTransport->SetupDataIn(writeBuf);

	// clear the sense info

	iSenseInfo.SetSense(TSenseInfo::ENoSense);

	return ETrue;

	}

/**

Command Parser for the INQUIRY command (0x12)

@param aLun Logic unit number

@return ETrue if successful,

*/

TBool CScsiServerProtocol::HandleInquiry(const TScsiServerReq& aRequest)

	{

    __MSFNLOG

    const TScsiServerInquiryReq request = static_cast<const TScsiServerInquiryReq&>(aRequest);

	if (request.iCmdDt || request.iEvpd || request.iPage || iLun >= KUsbMsMaxDrives)

		{

		iSenseInfo.SetSense(TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);

		return EFalse;

		}

    TScsiServerInquiryResp inquiry(iConfig);

    inquiry.SetAllocationLength(request.iAllocationLength);

#ifdef MSDC_TESTMODE

    if (iTestParser && !iTestParser->Removable())

        {

        __TESTMODEPRINT("RMB Cleared");

        inquiry.SetNotRemovable();

        }

#endif

    inquiry.Encode(iCommandBuf);

    TUint length = inquiry.Length();

	TPtrC8 writeBuf = iCommandBuf.Left(length);

	iTransport->SetupDataIn(writeBuf);

	iSenseInfo.SetSense(TSenseInfo::ENoSense);

	return ETrue;

	}

/**

 Command Parser for the START STOP UNIT command (0x1B)

 @param aData command data (started form position 1)

 @param aLun Logic unit number

 @return ETrue if successful, TFalse otherwise

 */

TBool CScsiServerProtocol::HandleStartStopUnit(const TScsiServerReq& aRequest)

	{

    __MSFNLOG

	const TScsiServerStartStopUnitReq request = static_cast<const TScsiServerStartStopUnitReq&>(aRequest);

	if (request.iLoej)

		{

		if(request.iStart)	//Start unit

			{

			iDriveManager.Connect(iLun);

			__PRINT(_L("Load media\n"));

            // rd/wr publisher

			iBytesRead[iLun] = 0;

			iBytesWritten[iLun] = 0;

			// publish the initial values

			iWriteTransferPublisher->DoPublishDataTransferredEvent();

			iReadTransferPublisher->DoPublishDataTransferredEvent();

			}

		else		//Stop unit

			{

			iDriveManager.SetCritical(iLun, EFalse);

			iDriveManager.Disconnect(iLun);

			__PRINT(_L("Unload media\n"));

			}

		}

	if (request.iImmed)

		{

		return ETrue;

		}

	CMassStorageDrive* drive = iDriveManager.Drive(iLun);

	TInt  timeLeft (20);   // 1 sec timeout

	CMassStorageDrive::TMountState mountState;

	do

		{

		User::After(1000 * 50);		// 50 mSec

		--timeLeft;

		mountState = drive->MountState();

		if ((!request.iStart && mountState != CMassStorageDrive::EConnected)

			 ||

			 (request.iStart &&

				(mountState == CMassStorageDrive::EDisconnecting ||

               mountState == CMassStorageDrive::EConnected)))

			{

			return ETrue;

			}

		} while (timeLeft>0);

	//timeout happend

	iSenseInfo.SetSense(TSenseInfo::ENotReady,

						TSenseInfo::EAscLogicalUnitDoesNotRespondToSelection);

	return EFalse;

	}

/**