// Copyright (c) 2004-2009 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:
// SCSCI Protocol unit test cases classes
// 
//

/**
 @file
 @internalTechnology
*/

#ifndef __T_MS_SCSI_H__
#define __T_MS_SCSI_H__

#include <e32def.h>
#include <f32fsys.h> // for Proxy drive

#include "scsiprot.h"
#include "drivemanager.h"


/**
	test scsi transport
*/
class TTestScsiTransport : public MTransportBase
	{
public:
	TTestScsiTransport();

	// MTransportBase methods
public:
	inline virtual void SetupReadData(TPtr8& aData);
	inline virtual void SetupReadData(TUint aLength);
	inline virtual void SetupWriteData(TPtrC8& aData);
	inline virtual TInt Start();
	inline virtual TInt Stop();
	inline virtual void RegisterProtocol(MProtocolBase& aProtocol);
	inline virtual TInt BytesAvailable();

	// test specific methods / members
public:
	void InitialiseReadBuf();
	
public:
	//new
	inline  virtual TInt InitialiseTransportL(TInt aTransportLddFlag); 
	inline	virtual void GetCommandBufPtr(TPtr8& aDes, TUint aLength); 
	inline	virtual void GetReadDataBufPtr(TPtr8& aDes);
	inline	virtual void GetWriteDataBufPtr(TPtrC8& aDes); 
	inline  virtual void ProcessReadData(TAny* aAddress);

public:
	/** pointer to the protocol */
	MProtocolBase* iProtocol;
	
	/** reference to Write Data protocol buffer */
	TPtrC8 iBufWrite;

	/** reference to Read Data protocol buffer */
	TBuf8<KMaxBufSize*2> iBufRead;
	
	/**reference to Command protocol buffer */
	TBuf8<36> iBufCmd;

	/** Number of bytes available in the protocol buffer */
	TUint iReadLength;
	};


/**
	test scsi proxy drive
*/
class CTestProxyDrive : public CProxyDrive
	{
public:
	CTestProxyDrive();
	virtual ~CTestProxyDrive();
	

	virtual TInt Read(TInt64 aPos,TInt aLength,TDes8& aTrg);
	
	virtual TInt Write(TInt64 aPos,const TDesC8& aSrc);
	
	virtual TInt Caps(TDes8& anInfo);
	
	virtual TInt Initialise();
	
	
	// not implemented methods
	virtual TInt Dismounted()
		{ ASSERT(EFalse); return KErrNone; }
	virtual TInt Enlarge(TInt)
		{ ASSERT(EFalse); return KErrNone; }
	virtual TInt ReduceSize(TInt, TInt)
		{ ASSERT(EFalse); return KErrNone; }
	virtual TInt Read(TInt64, TInt, const TAny*, TInt, TInt)
		{ ASSERT(EFalse); return KErrNone; }
	virtual TInt Write(TInt64,TInt,const TAny*,TInt,TInt)
		{ ASSERT(EFalse); return KErrNone; }
	virtual TInt Format(TFormatInfo&)
		{ ASSERT(EFalse); return KErrNone; }
	virtual TInt Format(TInt64,TInt)
		{ ASSERT(EFalse); return KErrNone; }
	virtual TInt SetMountInfo(const TDesC8*, TInt)
		{ ASSERT(EFalse); return KErrNone; }
	virtual TInt ForceRemount(TUint)
		{ ASSERT(EFalse); return KErrNone; }
	virtual TInt Unlock(TMediaPassword&, TBool)
		{ ASSERT(EFalse); return KErrNone; }
	virtual TInt Lock(TMediaPassword&, TMediaPassword&, TBool)
		{ ASSERT(EFalse); return KErrNone; }
	virtual TInt Clear(TMediaPassword&)
		{ ASSERT(EFalse); return KErrNone; }
	virtual TInt ControlIO(const RMessagePtr2&,TInt,TAny*,TAny*)
		{ ASSERT(EFalse); return KErrNone; }
	virtual TInt DeleteNotify(TInt64, TInt)
		{ ASSERT(EFalse); return KErrNone; }
	virtual TInt ErasePassword()
		{ ASSERT(EFalse); return KErrNone; }

	// test specific members / methods
public:
	/** Proxy drive Caps */
	TLocalDriveCapsV4 iCaps;
	
	/** Buffer with data for reading or writing*/
	TBuf8<KMaxBufSize*2> iMediaBuf;

	};

/**
	base class to encapsulate a single SCSI protocol test
*/
class CScsiTest : public CBase
	{
	// static memebers
public:
	/** 
	Defines Lun used for testing
	*/
	static TInt TestLun;

public:
	virtual ~CScsiTest();
	static CScsiTest* NewLC();

public:
	TPtrC8& GetSenseCodePtr();
	void MountTestDrive ();
	void DismountTestDrive ();
	CMassStorageDrive* TestDrive();

	// decode command
	inline TBool DecodePacket(TPtrC8& aCmd);

private:
	CScsiTest();
	void  ConstructL();

public:
	/** 
	Drive Manager
	*/
	CDriveManager* iDriveManager;
	/** 
	SCSI protocol
	*/
	CScsiProtocol* iScsiProt;
	/** 
	Transport object
	*/
	TTestScsiTransport iTransport;
	
	/**
	Test proxy drive
	*/
	CTestProxyDrive iProxyDrive;

	/** 
	drive map 
	*/
	RArray<TInt> iDriveMap;

	};



//
//	wrapper classes
//
/** RequestSense wrapper class */
class TRequestSenseData
	{
public:
	inline TRequestSenseData(TPtrC8 aData);
	
	inline TInt8 Key();
	inline TInt8 AdditionalCode();
	inline TInt8 AdditionalCodeQualifier();
		
public:
	/** pointer to internal data */
	TPtrC8 iData;
	};

	
/** Inquiry wrapper class */
class TInquiryData
	{
public:
	inline TInquiryData(TPtrC8 aData);
	
	inline TInt8 DeviceType(); 			// 5 lower bits in 1st byte
	inline TBool RMB(); 				// high bit in 2nd byte
	inline TInt8 Version();				// 3rd byte
	inline TInt8 RespDataFrmt();		// 4th byte 
    // TBuf<8>
	inline TPtr8 VendorId();
	// TBuf<16>
	inline TPtr8 ProductId();
	// TBuf<4>
	inline TPtr8 RevisionLevel();
	inline TInt8 PeripheralQualifier();	// 3 highest bits in 1st byte
	inline TInt8 Length(); 				// length of Inquiry data
	
public:
	/** pointer to internal data */
	TPtrC8 iData;
	};


// 
// Command wrappers
// Notes: Every command wrapper has internal buffer
//		  11 or 7 bytes long. This buffer is used for 
//		  10 or 6 bytes long commands. An extra byte is 
//		  used for the size of an command (see implementation
//		  of scsi protocol).

/** Wrapper class for READ(10) WRITE(10) VERIFY(10) command */
class TReadWrite10Cmd
	{
public:
	TReadWrite10Cmd();
	
	void SetBlockAddress(TUint32 aAddress);
	inline void SetTransferLength(TUint16 aLength);
	inline void SetProtect(TUint8 aProtect);
	
	inline void SetRead();
	inline void SetWrite();
	inline void SetVerify();
	inline void SetBytChk (TBool aSet);
	
public:
	/** buffer with command data */
	TBuf8<11> iCmd;
	};

/** Wrapper class for MODE SENSE(6) command */
class TModeSenseCmd
	{
public:
	TModeSenseCmd();
	inline void SetPC (TUint8 aPc);
	inline void SetPageCode (TUint8 aPc);
	
public:
	/** buffer with command data */
	TBuf8<7> iCmd;
	};

/** Wrapper class for INQUIRY command */
class TInquiryCmd
	{
public:
	TInquiryCmd();
	
public:
	/** buffer with command data */
	TBuf8<7> iCmd;
	};

/** Wrapper class for TEST UNIT READY command */
class TTestUnitReadyCmd
	{
public:
	TTestUnitReadyCmd();
	
public:
	/** buffer with command data */
	TBuf8<7> iCmd;
	};

/** Wrapper class for PREVENT ALLOW MEDIA REMOVAL command */
class TMediaRemovalCmd
	{
public:
	TMediaRemovalCmd();
	
public:
	/** buffer with command data */
	TBuf8<7> iCmd;
	};

/** Wrapper class for READ CAPACITY command */
class TReadCapacityCmd
	{
public:
	TReadCapacityCmd();
	
public:
	/** buffer with command data */
	TBuf8<11> iCmd;
	};

/** Wrapper class for READ CAPACITY response */
class TReadCapacityResponse : public TPtrC8
	{
public:
	TReadCapacityResponse(const TDesC8 &aDes);
	
	inline TUint32 LBAddress();
	inline TUint32 BlockLength();
	};
	
#include "t_ms_scsi.inl"
	
#endif //__T_MS_SCSI_H__