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

//

#include <e32std.h>

#include "mtransport.h"

#include "mprotocol.h"

#include "scsiprot.h"

#ifdef MSDC_MULTITHREADED

#include "rwdrivethread.h"

#endif // MSDC_MULTITHREADED

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "scsiprotTraces.h"

#endif

// Helper macros

#define LBA(x) static_cast<TUint32>((x[3] << 24) | (x[4] << 16) | (x[5] << 8) | x[6])

#define LEN(x) static_cast<TUint16>((x[8] << 8) | x[9])

static const TUint32 KDefaultBlockSize = 0x200;  //default block size for FAT

static const TUint KUndefinedLun = 0xFFFF;

static const TUint8 KAllPages = 0x3F;

static const TUint8 KChangeableValues = 0x1;

static const TUint8 KDefaultValues = 0x2;

/**

Default constructor for TSenseInfo

*/

TSenseInfo::TSenseInfo()

    : iSenseCode(ENoSense),

      iAdditional(EAscNull),

      iQualifier(EAscqNull)

    {}

/**

Set sense with no additional info.

@param aSenseCode sense key

*/

void TSenseInfo::SetSense(TSenseCode aSenseCode)

    {

    iSenseCode = static_cast<TUint8>(aSenseCode);

    iAdditional = EAscNull;

    iQualifier = EAscqNull;

    OstTraceExt3(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_SETSENSE1, "    SENSE CODE %d ASC %d ASC %d", iSenseCode, iAdditional, iQualifier);

    }

/**

Set sense with additional info.

@param aSenseCode sense key

@param aAdditional additional sense code (ASC)

*/

void TSenseInfo::SetSense(TSenseCode aSenseCode, TAdditionalCode aAdditional)

    {

    iSenseCode = static_cast<TUint8>(aSenseCode);

    iAdditional = static_cast<TUint8>(aAdditional);

    iQualifier = EAscqNull;

    OstTraceExt3(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_SETSENSE2, "    SENSE CODE %d ASC %d ASC %d", iSenseCode, iAdditional, iQualifier);

    }

/**

Set sense with additional info and qualifier.

@param aSenseCode sense key

@param aAdditional additional sense code (ASC)

@param aQualifier additional sense code qualifier (ASCQ)

*/

void TSenseInfo::SetSense(TSenseCode aSenseCode,

                          TAdditionalCode aAdditional,

                          TAdditionalSenseCodeQualifier aQualifier)

    {

    iSenseCode = static_cast<TUint8>(aSenseCode);

    iAdditional = static_cast<TUint8>(aAdditional);

    iQualifier = static_cast<TUint8>(aQualifier);

    OstTraceExt3(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_SETSENSE3, "    SENSE CODE %d ASC %d ASC %d", iSenseCode, iAdditional, iQualifier);

    }

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

/**

Creates the CScsiProtocol object.  Called during controller initialisation.

@param aDriveManager reference to the drive manager object

*/

CScsiProtocol* CScsiProtocol::NewL(CDriveManager& aDriveManager)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

/**

c'tor

@param aDriveManager reference to the drive manager object

*/

CScsiProtocol::CScsiProtocol(CDriveManager& aDriveManager):

    iDriveManager(aDriveManager),

    iLastCommand(EUndefinedCommand),

    iLastLun(KUndefinedLun),

    iMediaWriteSize(KDefaultMediaWriteSize)

    {

#ifdef USB_TRANSFER_PUBLISHER

    iWriteTransferPublisher = CUsbWriteTransferPublisher::NewL(iBytesWritten);

    iReadTransferPublisher = CUsbReadTransferPublisher::NewL(iBytesRead);

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

        {

        iBytesRead[i] = 0;

        iBytesWritten[i] = 0;

        }

#else

    iWriteTransferPublisher = CDriveWriteTransferPublisher::NewL(aDriveManager.iDrives);

    iReadTransferPublisher = CDriveReadTransferPublisher::NewL(aDriveManager.iDrives);

#endif

    }

CScsiProtocol::~CScsiProtocol()

    {

#ifdef MSDC_MULTITHREADED

    OstTrace0(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_DES, "Deleting Drive Threads");

    delete iWriteDriveThread;

    delete iReadDriveThread;

#endif // MSDC_MULTITHREADED

    delete iWriteTransferPublisher;

    delete iReadTransferPublisher;

    }

void CScsiProtocol::ConstructL()

    {

#ifdef MSDC_MULTITHREADED

    OstTrace0(TRACE_SMASSSTORAGE, _CSCSIPROTOCOL, "Creating Drive Threads");

    iWriteDriveThread = CWriteDriveThread::NewL();

    iReadDriveThread = CReadDriveThread::NewL();

#endif // MSDC_MULTITHREADED

    }

/**

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

@param aTransport pointer to the transport object

*/

void CScsiProtocol::RegisterTransport(MTransportBase* aTransport)

    {

    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 CScsiProtocol::ReportHighSpeedDevice()

    {

    iMediaWriteSize = KHsMediaWriteSize;

    OstTrace1(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_REPORTHIGHSPEEDDEVICE,

              "HS Device reported: SCSI will use 0x%x bytes disk write size", iMediaWriteSize);

    }

TInt CScsiProtocol::SetScsiParameters(TMassStorageConfig aConfig)

    {

    iConfig = aConfig;

    return KErrNone;

    }

#ifdef MSDC_MULTITHREADED

void CScsiProtocol::ProcessWriteComplete (TUint8* aAddress, TAny* aPtr)

    {

    ((CScsiProtocol*)aPtr)->iTransport->ProcessReadData(aAddress);

    }

void CScsiProtocol::InitializeBufferPointers(TPtr8& aDes1, TPtr8& aDes2) // Todo Change name later - InitializeReadBufferSomething

    {

    iReadDriveThread->iThreadContext->iBuffer.SetUpReadBuf(aDes1, aDes2);

    }

#endif

/**

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 CScsiProtocol::DecodePacket(TPtrC8& aData, TUint aLun)

    {

    TUint command = aData[1];

    if (command != ERequestSense)

        {

        iSenseInfo.SetSense(TSenseInfo::ENoSense);

        }

    OstTraceExt2(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_DECODEPACKET, "Command=0x%x LUN=%d", command, aLun);

    switch (command)

        {

        case ETestUnitReady:

            HandleUnitReady(aLun);

            break;

        case ERequestSense:

            HandleRequestSense(aData);

            break;

        case EInquiry:

            HandleInquiry(aData, aLun);

            break;

        case EModeSense6:

            HandleModeSense6(aData, aLun);

            break;

        case EModeSense10:

            HandleModeSense10(aData, aLun);

            break;

        case EStartStopUnit:

            HandleStartStopUnit(aData, aLun);

            break;

        case EPreventMediaRemoval:

            HandlePreventMediaRemoval(aData, aLun);

            break;

        case EReadCapacity:

            HandleReadCapacity(aData, aLun);

            break;

        case ERead10:

            HandleRead10(aData, aLun);

            break;

        case EWrite10:

            HandleWrite10(aData,aLun);

            break;

        case EVerify10:

            HandleVerify10(aData, aLun);

            break;

        case EReadFormatCapacities:

            HandleReadFormatCapacities(aLun);

            break;

        default:

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

        }

    return(iSenseInfo.SenseOk());

    }

/**

Checks if drive ready

@param aLun Logic unit number

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

*/

CMassStorageDrive* CScsiProtocol::GetCheckDrive(TUint aLun)

    {

    TInt err=KErrNone;

#ifdef MSDC_MULTITHREADED

    // check for deferred errors

    if (iWriteDriveThread->DeferredError())

        {

        iWriteDriveThread->ClearDeferredError();

        iDeferredSenseInfo.SetSense(TSenseInfo::EMediumError);

        return NULL;

        }

#endif

    CMassStorageDrive* drive= iDriveManager.Drive(aLun, err);

    if (err !=KErrNone || drive == NULL)

        {

        OstTrace0(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_GETCHECKDRIVE1, "No drive available");

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

        return NULL;

        }

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

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

        {

        OstTrace0(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_GETCHECKDRIVE2, "Drive disconnected");

        iSenseInfo.SetSense(TSenseInfo::ENotReady,

                            TSenseInfo::EMediaNotPresent);

        return NULL;

        }

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

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

        {

        OstTrace1(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_GETCHECKDRIVE3, "Media not present or locked. state =0x%X", state);

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

        return NULL;

        }

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

        {

        OstTrace0(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_GETCHECKDRIVE4, "Media was changed");

        // SAM-2 Section 5.9.5 Unit Attention Condition

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

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

        return NULL;

        }

    if (mountState == CMassStorageDrive::EDisconnecting)

        {

        OstTrace0(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_GETCHECKDRIVE5, "Drive disconnecting");

        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 CScsiProtocol::HandleUnitReady(TUint aLun)

    {

    OstTrace0(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_TESTUNITREADY, ">>> TEST UNIT READY");

#ifdef MSDC_MULTITHREADED

    iWriteDriveThread->WaitForWriteEmpty();

#endif

    return GetCheckDrive(aLun) ? (TBool)ETrue : (TBool)EFalse;

    }

/**

Command Parser for the REQUEST SENSE command (0x03)

@return ETrue if successful,

*/

TBool CScsiProtocol::HandleRequestSense(TPtrC8& aData)

    {

    OstTrace0(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_REQUESTSENSE, ">>> REQUEST SENSE");

    TUint length = aData[5];

    OstTrace1(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_REQUESTSENSE1, "    length = %d", length);

    TPtr8 writeBuf(NULL, 0);

    iTransport->GetCommandBufPtr(writeBuf, KRequestSenseCommandLength);

    writeBuf.FillZ(KRequestSenseCommandLength);

    TSenseInfo* senseInfo;

#ifdef MSDC_MULTITHREADED

    if (!iDeferredSenseInfo.SenseOk())

        {

        writeBuf[00] = 0x71; //(deferred errors)

        senseInfo = &iDeferredSenseInfo;

        }

    else

        {

        writeBuf[00] = 0x70; //(current errors)

        senseInfo = &iSenseInfo;

        }

#else

    senseInfo = &iSenseInfo;

    writeBuf[00] = 0x70; //(current errors)

#endif

    writeBuf[02] = static_cast<TUint8>(senseInfo->iSenseCode & 0x0F);

    writeBuf[12] = senseInfo->iAdditional;

    writeBuf[13] = senseInfo->iQualifier;

    if (length<18 && length >=8)

        {

        writeBuf.SetLength(length);  //length of response code data

        writeBuf[07] = TUint8(length - 8);  //additional sence length

        }

    else if (length >= KRequestSenseCommandLength)

        {

        writeBuf[07] = KRequestSenseCommandLength - 8;  // we have max 18 byte to send

        }

    OstTraceExt4(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_REQUESTSENSE2,

             "    Response=0x%x Sense=0x%x, Additional=0x%x, Qualifier=0x%x",

             (TUint)writeBuf[0], (TUint)writeBuf[02], (TUint)writeBuf[12], (TUint)writeBuf[13]);

    TPtrC8 writeBuf1 = writeBuf.Left(length);

    iTransport->SetupWriteData(writeBuf1);

    // clear the sense info

    iSenseInfo.SetSense(TSenseInfo::ENoSense);

#ifdef MSDC_MULTITHREADED

    iDeferredSenseInfo.SetSense(TSenseInfo::ENoSense);

#endif

    return ETrue;

    }

/**

Command Parser for the INQUIRY command (0x12)

@param aLun Logic unit number

@return ETrue if successful,

*/

TBool CScsiProtocol::HandleInquiry(TPtrC8& aData, TUint  aLun )

    {

    OstTrace0(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_INQUIRY, ">>> INQUIRY");

    TBool cmdDt = aData[2] & 0x2;

    TBool evpd  = aData[2] & 0x1;

    TUint8 page = aData[3];

    if (cmdDt || evpd || page || aLun >= KUsbMsMaxDrives)

        {

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

        return EFalse;

        }

    TPtr8 writeBuf(NULL, 0);

    iTransport->GetCommandBufPtr(writeBuf, KInquiryCommandLength);

    writeBuf.FillZ(KInquiryCommandLength);

    writeBuf[1] = 0x80; // MSB: RMB : Removable

    writeBuf[3] = 0x02; // AERC, TrmTsk, NormACA, Response Data Format

    writeBuf[4] = 0x1F; // Additional Length

    TPtr8 vendorId(&writeBuf[8], 8, 8);     // Vendor ID (Vendor Specific/Logged by T10)

    vendorId.Fill(' ', 8);

    vendorId.Copy(iConfig.iVendorId);

    TPtr8 productId(&writeBuf[16], 16, 16); // Product ID (Vendor Specific)

    productId.Fill(' ', 16);

    productId.Copy(iConfig.iProductId);

    TPtr8 productRev(&writeBuf[32], 4, 4);      // Product Revision Level (Vendor Specific)

    productRev.Fill(' ', 4);

    productRev.Copy(iConfig.iProductRev);

    OstTraceData(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_INQUIRY1, "Vendor ID %s", vendorId.Ptr(), vendorId.Length());

    OstTraceData(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_INQUIRY2, "Product ID %s", productId.Ptr(), productId.Length());

    OstTraceData(TRACE_SMASSSTORAGE_SCSI, CSCSIPROTOCOL_INQUIRY3, "Product Rev %s", productRev.Ptr(), productRev.Length());

    TUint length = aData[5];

    TPtrC8 writeBuf1 = writeBuf.Left(length);

    iTransport->SetupWriteData(writeBuf1);

    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 CScsiProtocol::HandleStartStopUnit(TPtrC8& aData, TUint aLun)