// Copyright (c) 2004-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:

// SCSI Protocol layer for USB Mass Storage

//

//

/**

 @file

 @internalTechnology

*/

#ifndef __SCSIPROT_H__

#define __SCSIPROT_H__

// Header files

#include "drivemanager.h"

// Define MSDC_MULTITHREADED to use Mass Storage multi-threaded (Double-buffering) disk read/writes.

// smassstorage_db.mmp defines this macro.

#if defined MSDC_MULTITHREADED

class CWriteDriveThread;

class CReadDriveThread;

#endif

// Display time taken to write data to disk

//#define MEASURE_AND_DISPLAY_WRITE_TIME

// Display time taken to read data from disk

//#define MEASURE_AND_DISPLAY_READ_TIME

// Maximum size for SCSI Read10 Write10 and Verify10 commands

// Windows requests size of 64K whereas MAC requests size of 128K

static const TUint32 KMaxBufSize = 128 * 1024;

// Write to media when data is available

static const TUint32 KDefaultMediaWriteSize = 4 * 1024;

// Use in the HS case a write size of 64KB

static const TUint32 KHsMediaWriteSize = 64 * 1024;

/**

Sense Info

*/

class TSenseInfo

    {

public:

    // Spec: SCSI Primary Commands 3 (SPC-3)

    // Section 4.5.6 Sense key and sense code defintions

    // Table 27 - Sense key descriptions

    enum TSenseCode

        {

        ENoSense        = 0,

        ERecoveredError = 1,

        ENotReady       = 2,

        EMediumError    = 3,

        EHardwareError  = 4,

        EIllegalRequest = 5,

        EUnitAttention  = 6,

        EDataProtection = 7,

        EBlankCheck     = 8,

        EVendorSpecific = 9,

        ECopyAborted    = 10,

        EAbortedCommand = 11,

        EDataOverflow   = 13,

        EMisCompare     = 14

        };

    // Table 28 - ASC and ASQ assignments

    enum TAdditionalCode

        {

        EAscNull                                 = 0x00,

        EAscLogicalUnitNotReady                  = 0x04,

        EAscLogicalUnitDoesNotRespondToSelection = 0x05,

        EInvalidCmdCode                          = 0x20,

        ELbaOutOfRange                           = 0x21,

        EInvalidFieldInCdb                       = 0x24,

        ELuNotSupported                          = 0x25,

        EWriteProtected                          = 0x27,

        ENotReadyToReadyChange                   = 0x28,

        EMediaNotPresent                         = 0x3A,

        EInsufficientRes                         = 0x55

        };

    enum TAdditionalSenseCodeQualifier

        {

        EAscqNull                                  = 0x00,

        EAscqLogicalUnitIsInProcessOfBecomingReady = 0x01

        };

public:

    TSenseInfo();

    void SetSense(TSenseCode aSenseCode);

    void SetSense(TSenseCode aSenseCode,

                  TAdditionalCode aAdditional);

    void SetSense(TSenseCode aSenseCode,

                  TAdditionalCode aAdditional,

                  TAdditionalSenseCodeQualifier aQualifier);

    TBool SenseOk();

public:

    TUint8 iSenseCode;

    TUint8 iAdditional;

    TUint8 iQualifier;

    };

/**

Returns EFalse if a sense code has been set.

Note that ENoSense indicates that there is no specific sense key infotmation

to be reported and the command was successful.

*/

inline TBool TSenseInfo::SenseOk()

    {

    return (iSenseCode == ENoSense);

    }

const TUint KModeSense6CommandLength = 4;

const TUint KModeSense10CommandLength = 8;

const TUint KReadCapacityCommandLength = 8;

const TUint KReadFormatCapacitiesCommandLength = 12;

const TUint KRequestSenseCommandLength = 18;

const TUint KInquiryCommandLength = 36;

/**

The CScsiProtocol is responsible for interpreting the data received from the Transpor layer

and where appropriate routing specific requests through to the appropriate drive unit.

@internalTechnology

*/

class CScsiProtocol : public CBase, public MProtocolBase

    {

public:

    enum TCommand

    {

    ETestUnitReady          = 0x00,

    ERequestSense           = 0x03,

    EInquiry                = 0x12,

    EModeSense6             = 0x1A,

    EStartStopUnit          = 0x1B,

    EPreventMediaRemoval    = 0x1E,

    EReadFormatCapacities   = 0x23,

    EReadCapacity           = 0x25,

    ERead10                 = 0x28,

    EWrite10                = 0x2A,

    EVerify10               = 0x2f,

    EModeSense10            = 0x5A,

    EUndefinedCommand       = 0xFF

    };

public:

    static CScsiProtocol* NewL(CDriveManager& aDriveManager);

    void RegisterTransport(MTransportBase* aTransport);

    void ReportHighSpeedDevice();

    TBool DecodePacket(TPtrC8& aData, TUint aLun);

    TInt ReadComplete(TInt aError);

    TInt SetScsiParameters(TMassStorageConfig aConfig);

    TInt Cancel();

    ~CScsiProtocol();

#ifdef MSDC_MULTITHREADED

    void InitializeBufferPointers(TPtr8& aDes1, TPtr8& aDes2);

    static void ProcessWriteComplete (TUint8* aAddress, TAny* aPtr); //todo const

#endif

private:

    CScsiProtocol(CDriveManager& aDriveManager);

    void  ConstructL();

    CMassStorageDrive* GetCheckDrive(TUint aLun);

    TBool HandleUnitReady(TUint aLun);

    TBool HandleRequestSense(TPtrC8& aData);

    TBool HandleInquiry(TPtrC8& aData, TUint aLun);

    TBool HandleStartStopUnit(TPtrC8& aData, TUint aLun);

    TBool HandlePreventMediaRemoval(TPtrC8& aData, TUint aLun);

    TBool HandleReadCapacity(TPtrC8& aData, TUint aLun);

    TBool HandleRead10(TPtrC8& aData, TUint aLun);

    TBool HandleWrite10(TPtrC8& aData, TUint aLun);

    TBool HandleVerify10(TPtrC8& aData, TUint aLun);

    TBool HandleModeSense6(TPtrC8& aData, TUint aLun);

    TBool HandleModeSense10(TPtrC8& aData, TUint aLun);

    TBool HandleReadFormatCapacities(TUint aLun);

private:

    /** Configuration data for INQUIRY command*/

    TMassStorageConfig iConfig;

    /** reference to the Drive Manager */

    CDriveManager& iDriveManager;

    /** pointer to the transport level */

    MTransportBase* iTransport;

    /** Sense Info */

    TSenseInfo iSenseInfo;

#ifdef MSDC_MULTITHREADED

    /** Sense Info */

    TSenseInfo iDeferredSenseInfo;

#endif

    /** Start offset (in bytes) for Write/Verify */

    TInt64 iOffset;

    /** Last command for SetupRead (Write or Verify) */

    TUint8 iLastCommand;

    /** LUN for SetupRead */

    TUint iLastLun;

#ifdef SIMDISK

    CArrayFixFlat<TUint8>* iSimDisk;

#endif

    /** The number of bytes remaining to be read from the host for write operations */

    TUint32 iBytesRemain;

    /** Write to the media when this amount of data is available */

    TUint32 iMediaWriteSize;

#ifdef MSDC_MULTITHREADED

    /** Ptr to Write Thread instance */

    CWriteDriveThread* iWriteDriveThread;

    /** Ptr to Read Thread instance */

    CReadDriveThread* iReadDriveThread;

#endif // MSDC_MULTITHREADED

#ifdef USB_TRANSFER_PUBLISHER

    /**

    Publish and subscribe properties for tracking data transfer volume

    */

    CUsbWriteTransferPublisher* iWriteTransferPublisher;

    CUsbReadTransferPublisher* iReadTransferPublisher;

    /**

    Cumulative bytes read

    */

    TFixedArray<TInt64, KUsbMsMaxDrives> iBytesRead;

    /**

    Cumulative bytes written

    */

    TFixedArray<TInt64, KUsbMsMaxDrives> iBytesWritten;

#else

    /**

    Publish and subscribe properties for tracking data transfer volume

    */

    CDriveWriteTransferPublisher* iWriteTransferPublisher;

    CDriveReadTransferPublisher* iReadTransferPublisher;

#endif

    };

#endif // __SCSIPROT_H__