#include <e32std.h>

#include "mtransport.h"

#include "mprotocol.h"

#ifdef MSDC_MULTITHREADED

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "scsiprotTraces.h"

#endif

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;

    : iSenseCode(ENoSense),

      iAdditional(EAscNull),

      iQualifier(EAscqNull)

    {}

    {

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

    }

@param aAdditional additional sense code (ASC)

    {

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

    }

@param aSenseCode sense key

@param aAdditional additional sense code (ASC)

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

    }

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

    iDriveManager(aDriveManager),

    iLastCommand(EUndefinedCommand),

    iLastLun(KUndefinedLun),

    iMediaWriteSize(KDefaultMediaWriteSize)

    {

    iWriteTransferPublisher = CUsbWriteTransferPublisher::NewL(iBytesWritten);

    iReadTransferPublisher = CUsbReadTransferPublisher::NewL(iBytesRead);

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

        {

        iBytesRead[i] = 0;

        iBytesWritten[i] = 0;

        }

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

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

    }

    {

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

    delete iWriteDriveThread;

    delete iReadDriveThread;

    delete iWriteTransferPublisher;

    delete iReadTransferPublisher;

    }

    {

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

    iWriteDriveThread = CWriteDriveThread::NewL();

    iReadDriveThread = CReadDriveThread::NewL();

    }

    {

    iTransport = aTransport;

    }

    {

    iMediaWriteSize = KHsMediaWriteSize;

    OstTrace1(TRACE_SMASSSTORAGE, CSCSIPROTOCOL_REPORTHIGHSPEEDDEVICE,

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

    }

    {

    iConfig = aConfig;

    return KErrNone;

    }

    {

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

    }

    {

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

    }

    {

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

    }

@param aLun Logic unit number

    {

    TInt err=KErrNone;

    // check for deferred errors

    if (iWriteDriveThread->DeferredError())

        {

        iWriteDriveThread->ClearDeferredError();

        iDeferredSenseInfo.SetSense(TSenseInfo::EMediumError);

        return NULL;

        }

    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;

    }

@param aLun Logic unit number

@return ETrue if successful,

    {

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

    iWriteDriveThread->WaitForWriteEmpty();

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

    }

@return ETrue if successful,

    {

    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;

    if (!iDeferredSenseInfo.SenseOk())

        {

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

        senseInfo = &iDeferredSenseInfo;

        }

    else

        {

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

        senseInfo = &iSenseInfo;

        }

    senseInfo = &iSenseInfo;

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

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

    iDeferredSenseInfo.SetSense(TSenseInfo::ENoSense);

    return ETrue;

    }

@param aLun Logic unit number

@return ETrue if successful,

    {

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

    TPtrC8 writeBuf1 = writeBuf.Left(length);

    iTransport->SetupWriteData(writeBuf1);

    iSenseInfo.SetSense(TSenseInfo::ENoSense);

    return ETrue;

    }

 @param aLun Logic unit number