// Copyright (c) 2008-2010 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 "msctypes.h"

#include "shared.h"

#include "msgservice.h"

#include "mtransport.h"

#include "mprotocol.h"

#include "tscsiclientreq.h"

#include "tscsiprimarycmds.h"

#include "tscsiblockcmds.h"

#include "mblocktransferprotocol.h"

#include "tblocktransfer.h"

#include "tsbcclientinterface.h"

#include "tspcclientinterface.h"

#include "cmassstoragefsm.h"

#include "cscsiprotocol.h"

#include "usbmshostpanic.h"

/**

Create the CScsiProtocol object.

@param aLun The LUN for the device represented by this object

@param aTransport The transport interface

@param aStatusPollingInterval The polling interval

@return CScsiProtocol* A reference to the

*/

CScsiProtocol* CScsiProtocol::NewL(TLun aLun, MTransport& aTransport)

    {

    }

void CScsiProtocol::ConstructL(TLun aLun)

    {

    iFsm = CMassStorageFsm::NewL(*this);

    const TInt blockLength = 0x200;

    iHeadbuf.CreateL(blockLength);

    iTailbuf.CreateL(blockLength);

    }

CScsiProtocol::CScsiProtocol(MTransport& aTransport)

:   iSpcInterface(aTransport),

    iSbcInterface(NULL)

    {

    }

CScsiProtocol::~CScsiProtocol()

    {

    delete iFsm;

    iHeadbuf.Close();

    iTailbuf.Close();

    delete iSbcInterface;

    }

void CScsiProtocol::InitialiseUnitL()

    {

    iState = EDisconnected;

    TInt retryCounter = 20;

    do

        {

        retryCounter--;

        TInt err = iFsm->ConnectLogicalUnitL();

        if (err == KErrNotSupported)

            {

            break;

            }

        if (iFsm->IsConnected())

            {

            iState = EConnected;

            break;

            }

        User::After(1000 * 200);    // 200 mS

        }

    while (retryCounter);

void CScsiProtocol::UninitialiseUnitL()

    {

    iFsm->DisconnectLogicalUnitL();

    }

TBool CScsiProtocol::IsConnected()

    {

    }

void CScsiProtocol::ReadL(TPos aPos,

                          TDes8& aBuf,

                          TInt aLength)

    {

    if (!iSbcInterface)

        User::Leave(KErrNotSupported);

    if(!IsConnected())

    iSbcInterface->iBlockTransfer.ReadL(*this, aPos, aLength, aBuf);

    }

void CScsiProtocol::BlockReadL(TPos aPos, TDes8& aCopybuf, TInt aLen)

    {

    if (!iSbcInterface)

        User::Leave(KErrNotSupported);

                   User::Panic(KUsbMsHostPanicCat, EBlockDevice));

    const TInt blockLen = iSbcInterface->iBlockTransfer.BlockLength();

    TInt len = aLen;

    TInt64 lba = aPos / static_cast<TInt64>(blockLen);

    if (I64HIGH(lba))

        {

        User::LeaveIfError(KErrOverflow);

        }

    if (err)

        {

        User::LeaveIfError(DoCheckConditionL());

        }

    // handle residue

    while (len != aLen)

        {

        // read next block

        // full blocks read in bytes

        TInt bytesRead = len/blockLen * blockLen;

        aPos += bytesRead;

        aLen -= bytesRead;

        len = aLen;

        aCopybuf.SetLength(bytesRead);

        // read rest of the block

        TInt err = iSbcInterface->Read10L(aPos/blockLen, aCopybuf, len);

        if (err)

            {

            User::LeaveIfError(DoCheckConditionL());

            }

        }

    }

void CScsiProtocol::WriteL(TPos aPosition,

                           TDesC8& aBuf,

                           TInt aLength)

    {

    if (!iSbcInterface)

        User::Leave(KErrNotSupported);

    if(!IsConnected())

    iSbcInterface->iBlockTransfer.WriteL(*this, aPosition, aLength, aBuf);

    }

void CScsiProtocol::BlockWriteL(TPos aPos, TDesC8& aCopybuf, TUint aOffset, TInt aLen)

    {

    if (!iSbcInterface)

        User::Leave(KErrNotSupported);

                   User::Panic(KUsbMsHostPanicCat, EBlockDevice));

    const TInt blockLen = iSbcInterface->iBlockTransfer.BlockLength();

    TInt len = aLen;

    if (err)

        {

        User::LeaveIfError(DoCheckConditionL());

        }

    while (len != aLen)

        {

        // handle residue

        // write next block

        // full blocks written in bytes

        TInt bytesWritten = len/blockLen * blockLen;

        aPos += bytesWritten;

        aLen -= bytesWritten;

        len = aLen;

        TPtrC8 buf = aCopybuf.Mid(bytesWritten);

        // write rest of the block

        TInt err = iSbcInterface->Write10L(aPos/blockLen, buf, aOffset, len);

        if (err)

            {

            User::LeaveIfError(DoCheckConditionL());

            }

        }

    }

void CScsiProtocol::GetCapacityL(TCapsInfo& aCapsInfo)

    {

    if (!IsConnected())

        {

        if (!DoScsiReadyCheckEventL())

            return;

        }

    if (!iSbcInterface)

        {

        aCapsInfo.iMediaType = EMediaCdRom;

        aCapsInfo.iNumberOfBlocks = 0;

        aCapsInfo.iBlockLength = 0;

        aCapsInfo.iWriteProtect = ETrue;

        return;

        }

    aCapsInfo.iMediaType = EMediaHardDisk;

    // Retry ReadCapacity10L if stalled

    TInt stallCounter = 4;

    TInt err = KErrNone;

    do

        {

        err = iSbcInterface->ReadCapacity10L(lastLba, blockLength);

        } while (err == KErrCommandStalled && stallCounter-- > 0);

    if (err)

        {

        // DoCheckConditionL clears sense error

        // Media not present will return KErrNotReady so leave here

        User::LeaveIfError(DoCheckConditionL());

        }

    // update iWriteProtect

    err = MsModeSense10L();

    if (err)

        {

        if (err == KErrCommandFailed)

            {

            // Clear sense error

            err = DoCheckConditionL();

            // ignore error if unsupported

            if (err != KErrUnknown)

                {

                User::LeaveIfError(err);

                }

            }

        err = MsModeSense6L();

        if (err == KErrCommandFailed)

            {

            // Clear sense error

            err = DoCheckConditionL();

            // ignore error if unsupported

            if (err != KErrUnknown)

                {

                User::LeaveIfError(err);

                }

        }

    aCapsInfo.iNumberOfBlocks = lastLba + 1;

    aCapsInfo.iBlockLength = blockLength;

    aCapsInfo.iWriteProtect = iWriteProtect;

    }

/**

Perform SCSI INQUIRY command. The function leaves if the device response is not

compliant with the protocol standard.

@return TInt KErrNone if successful otherwise KErrCommandFailed to indicate a

device status error

*/

TInt CScsiProtocol::MsInquiryL()

    {

    ResetSbc();

   /**

    INQUIRY

   */

   /**

    SPC states

    - the INQUIRY data should be returned even though the device server is not

      ready for other commands.

    - If the standard INQUIRY data changes for any reason, the device server

      shall generate a unit attention condition

   */

    TPeripheralInfo info;

    TInt err = iSpcInterface.InquiryL(info);

    if (err)

        {

        // KErrCommandFailed

        return err;

        }

    // print reponse

    if (info.iPeripheralQualifier != 0 && info.iPeripheralQualifier != 1)

        {

        err = KErrUnknown;

        }

    else if (info.iPeripheralDeviceType == 0)

        {

        // SCSI SBC Direct access device

        iRemovableMedia = info.iRemovable;

        // SCSI Block device

        iSbcInterface = new (ELeave) TSbcClientInterface(iSpcInterface.Transport());

        iSbcInterface->InitBuffers(&iHeadbuf, &iTailbuf);

        err = KErrNone;

        }

    else if (info.iPeripheralDeviceType == 5)

        {

        // SCSI MMC-2 CD-ROM device

        iRemovableMedia = info.iRemovable;

        // KErrNotSupported. If SCSI support is extended in future then

        // TSbcInterface class should be replaced with a proper interface class.

        iSbcInterface = NULL;

        err = KErrNone;

        }

    else

        {

        }

    return err;

    }

/**

Perform SCSI TEST UNIT READY command. The function leaves if the device response

is not compliant with the protocol standard.

@return TInt KErrNone if successful or otherwise KErrCommandFailed to indicate a

device status error

*/

TInt CScsiProtocol::MsTestUnitReadyL()

    {

    /* TestUnitReady */

    return iSpcInterface.TestUnitReadyL();

    }

/**

Perform SCSI READ CAPACITY (10) command. The function leaves if the device

response is not compliant with the protocol standard.

Before a block device can be read or written the media's capacity (LAST LBA and

BLOCK SIZE) must be obtained. This function is used to initialise TBlockTransfer

with the capacity parameters via TSbcInterface::ReadCapcaityL().

@return TInt KErrNone if successful, KErrCommandFailed to indicate a

device status error, KErrCommandStalled to indicate a device stall

*/

TInt CScsiProtocol::MsReadCapacityL()

    {

    if (!iSbcInterface)

        {

        User::Leave(KErrNotSupported);

        }

    // READ CAPACITY

    TUint32 blockSize;

    TUint32 lastLba;

    TInt err = iSbcInterface->ReadCapacity10L(lastLba, blockSize);

    return err;

    }

/**

Perform MODE SENSE (10) command. The function leaves if the device response is

not compliant with the protocol standard.

@return TInt KErrNone if successful, KErrCommandFailed to indicate a

device status error, KErrCommandStalled to indicate a device stall

*/

TInt CScsiProtocol::MsModeSense10L()

    {

    if (!iSbcInterface)

        User::Leave(KErrNotSupported);

    TBool writeProtected;

    TInt err = iSbcInterface->ModeSense10L(TSbcClientInterface::EReturnAllModePages, writeProtected);

    if (!err)

        {

        iWriteProtect = writeProtected;

        }

    return err;

    }

/**

Perform SCSI MODE SENSE (6) command. The function leaves if the device response

is not compliant with the protocol standard.

@return TInt KErrNone if successful, KErrCommandFailed to indicate a

device status error, KErrCommandStalled to indicate a device stall

*/

TInt CScsiProtocol::MsModeSense6L()

    {

    if (!iSbcInterface)

        User::Leave(KErrNotSupported);

    TBool writeProtected;

    TInt err = iSbcInterface->ModeSense6L(TSbcClientInterface::EReturnAllModePages, writeProtected);

    if (!err)