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

// 

// 

#include "scsiprot.h"

#include "debug.h"

#include "mscfileserver.h"

// 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])

LOCAL_D const TUint KDefaultBlockSize = 0x800;  //default block size for MM

LOCAL_D const TUint KUndefinedLun = 0xFFFF;

LOCAL_D const TUint8 KAllPages = 0x3F;

LOCAL_D const TUint8 KChangeableValues = 0x1;

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

	}

/**

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;

	}

/**

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

	}

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

/**

Creates the CScsiProtocol object.  Called during controller initialisation.

@param aFsImage reference to the file system image

*/

CScsiProtocol* CScsiProtocol::NewL(CMscFileController& aController)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

/**

c'tor

@param aFsImage reference to the file system image

*/

CScsiProtocol::CScsiProtocol(CMscFileController& aController):

	iController(aController),

	iLastCommand(EUndefinedCommand),

	iLastLun(KUndefinedLun),

	iMediaWriteSize(KDefaultMediaWriteSize)

	{

	}

CScsiProtocol::~CScsiProtocol()

	{

	}

void CScsiProtocol::ConstructL()

	{

	TRACE_FUNC

	}

/**

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

@param aTransport pointer to the transport object

*/

void CScsiProtocol::RegisterTransport(MTransportBase* aTransport)

	{

	TRACE_FUNC

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

	{

	TRACE_FUNC

	iMediaWriteSize = KHsMediaWriteSize;

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

	        iMediaWriteSize ))

	}

TInt CScsiProtocol::SetScsiParameters(TMassStorageConfig aConfig)

	{

	TRACE_FUNC

	iConfig = aConfig;

	return KErrNone;

	}

/**

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)

	{

	TRACE_FUNC_ENTRY

	TUint8 command = aData[1];

	if (command != ERequestSense)

		{

		iSenseInfo.SetSense(TSenseInfo::ENoSense);

		}

	TRACE_INFO(( _L( "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 EModeSense:

            HandleModeSense(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 ERead12:

            HandleRead12(aData, aLun);

            break;

        case EReadTOC:

            HandleReadTOC(aData, aLun);

            break;

        case EGetConfiguration:

            HandleGetConfiguration(aData, aLun);

            break;

		default:

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

		}

	TRACE_INFO(( _L( "result = %d" ), iSenseInfo.SenseOk() ))

	TRACE_FUNC_EXIT

	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

*/

CFileSystemImage* CScsiProtocol::GetCheckFs(TUint aLun)

	{

	TRACE_FUNC

	TInt err = KErrNone;

	CFileSystemImage* image = iController.FsImage( aLun );

	if ( image == NULL )

		{

		TRACE_ERROR(( _L( "Illegal LUN %d" ), aLun ))

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

		return NULL;

		}

	// Image exists, ensure it is opened for access

    err = image->Open();

    if ( err == KErrNone )

        {

        // Image is now open, if it wasn't already

        TRACE_INFO(( _L( "Image opened successfully" ) ))

        return image;

        }

    else

        {

        // Either file doesn't exist or was removed

        TRACE_ERROR(( _L( "Error %d opening image" ), err ))

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

        }

    return NULL;

	}

/**

Command Parser for the UNIT READY command (0x00)

@param aLun Logic unit number 

@return ETrue if successful, 

*/

TBool CScsiProtocol::HandleUnitReady(TUint aLun)

	{

	TRACE_FUNC

	return ( GetCheckFs(aLun) != NULL );

	}

/**

Command Parser for the REQUEST SENSE command (0x03)

@return ETrue if successful, 

*/

TBool CScsiProtocol::HandleRequestSense(TPtrC8& aData)

	{

	TRACE_FUNC

	TUint length = aData[5];

	TRACE_INFO(( _L( "length = %d"), length ))

	iCommandBuf.FillZ(KRequestSenseCommandLength);

	TSenseInfo* senseInfo;

	senseInfo = &iSenseInfo;

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

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

	iCommandBuf[12] = senseInfo->iAdditional;

	iCommandBuf[13] = senseInfo->iQualifier;

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

		{

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

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

		}

	else if (length >= KRequestSenseCommandLength)

		{

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

		}

	TRACE_INFO(( _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(length);

	iTransport->SetupWriteData(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 CScsiProtocol::HandleInquiry(TPtrC8& aData, TUint /*aLun*/ )

	{

	TRACE_FUNC

	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;

		}

	iCommandBuf.FillZ(KInquiryCommandLength);

    iCommandBuf[0] = 0x05; // CD-ROM

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

    iCommandBuf[2] = 0x02; // Version SPC-3

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

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

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

	vendorId.Fill(' ', 8);

	vendorId.Copy(iConfig.iVendorId);

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

	productId.Fill(' ', 16);

	productId.Copy(iConfig.iProductId);

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

	productRev.Fill(' ', 4);

	productRev.Copy(iConfig.iProductRev);

    TUint length = aData[5];

	TPtrC8 writeBuf = iCommandBuf.Left(length);

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

	{

	TRACE_FUNC

    CFileSystemImage* image = GetCheckFs(aLun); 

    if ( image == NULL )

        {

        return EFalse;

        }

	const TUint8 KStartMask = 0x01;

	const TUint8 KImmedMask = 0x01;

	const TUint8 KLoejMask = 0x02;

	TBool immed = aData[2] & KImmedMask ? ETrue : EFalse;

	TBool start = aData[5] & KStartMask ? ETrue : EFalse;

	TBool loej = aData[5] & KLoejMask ? ETrue : EFalse;

	TRACE_INFO(( _L( "Data %X %X" ), aData[2], aData[5] ))

	TRACE_INFO(( _L( "IMMED = %d" ), immed ))

	TRACE_INFO(( _L( "START = %d"), start ))

	TRACE_INFO(( _L( "LOEJ  = %d" ), loej ))

	TInt err = KErrNone;

	if (loej)

		{

		if (start)	//Start unit

			{

			// GetCheckFs has already opened the image file

			TRACE_INFO(( _L( "Load media" ) ))

			}

		else		//Stop unit 

			{

			err = image->Close();

			TRACE_INFO(( _L( "Unload media" ) ))

			}

		}

	if (err != KErrNone)  //actually we have error here only if the LUN is incorrect 

		{

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

		return EFalse;

		}

	return ETrue;

	}

/**

Command Parser for the PREVENT/ALLOW MEDIA REMOVAL command (0x1E)

@param aData command data (started form position 1)

@param aLun Logic unit number 

@return ETrue if successful.

*/

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

	{

	TRACE_FUNC

    if ( GetCheckFs(aLun) == NULL )

        {

        return EFalse;

        }

	TInt prevent = aData[5] & 0x01;

	// locking is not supported

	if (prevent)

		{

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

		}

	return ETrue;

	}

/** Cancel active state, Invoked by transnport when it stops */

TInt CScsiProtocol::Cancel()

	{

	TRACE_FUNC

	return KErrNone;

	}

/**

Command Parser for the READ CAPACITY(10) command (0x25)

@param aData command data (started form position 1)

@param aLun Logic unit number 

@return ETrue if successful.

*/

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

	{

	TRACE_FUNC

	CFileSystemImage* image = GetCheckFs(aLun); 

    if ( image == NULL )

        {

        return EFalse;

        }

	TInt pmi = aData[9] & 0x01;

	TInt lba = aData[3] | aData[4] | aData[5] | aData[6];

	if (pmi || lba)   //do not support partial medium indicator

		{

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

		return EFalse;

		} 

	TInt64 driveBlocks = image->Size() / MAKE_TINT64(0, KDefaultBlockSize) - 1;

	iCommandBuf.FillZ(KReadCapacityCommandLength);

	if (I64HIGH(driveBlocks) == 0)

		{

		TUint32 numBlocks = I64LOW(driveBlocks);

		TRACE_INFO(( _L( "Block size=%d, NumBlocks=%d" ), 

		        KDefaultBlockSize, numBlocks ))

		iCommandBuf[0] = static_cast<TUint8>((numBlocks & 0xFF000000) >> 24);	// Number of blocks

		iCommandBuf[1] = static_cast<TUint8>((numBlocks & 0x00FF0000) >> 16);

		iCommandBuf[2] = static_cast<TUint8>((numBlocks & 0x0000FF00) >> 8);

		iCommandBuf[3] = static_cast<TUint8>((numBlocks & 0x000000FF));

		}

	else   

		{

		iCommandBuf[0] = iCommandBuf[1] = iCommandBuf[2] = iCommandBuf[3] = 0xFF;  // indicate that size more then )0xFFFFFFFF

		}

	iCommandBuf[4] = static_cast<TUint8>((KDefaultBlockSize & 0xFF000000) >> 24);	// Block Size

	iCommandBuf[5] = static_cast<TUint8>((KDefaultBlockSize & 0x00FF0000) >> 16);

	iCommandBuf[6] = static_cast<TUint8>((KDefaultBlockSize & 0x0000FF00) >> 8);

	iCommandBuf[7] = static_cast<TUint8>((KDefaultBlockSize & 0x000000FF));

	TPtrC8 writeBuf = iCommandBuf;

	iTransport->SetupWriteData(writeBuf);

	return ETrue;

	}