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



/**
 @file
 @internalTechnology
*/

#ifndef CBLOCKDEVICETESTER_H
#define CBLOCKDEVICETESTER_H

static const TInt KBlockSize = 0x200;

static const TInt KSizeInBlocks = 0x20;
static const TInt KSize = (KSizeInBlocks * KBlockSize);


typedef TUint TLba;
typedef TInt64 TPos;


class TLocalBuffer
    {
public:
    void Init();
    TPtrC8 Buffer() const {return iBuffer;}
    void Update(TInt aPos, TUint aLen);

public:
    TBuf8<KSize> iBuffer;
    };


class TLbaUtils
    {
public:
    static TPos Pos(TLba aLba);
    static TUint32 Length(TLba aBlocks);
    };


class RTargetMedia
    {
public:
    RTargetMedia(TInt aDriveNumber);
    void OpenL();
    void Close();

    TInt MediaRawWrite(TPos aPos, const TDesC8& aData);
    TInt MediaRawRead(TPos aPos, TUint32 aLen, TDes8& aData);

protected:
    RRawDisk iRawDisk;
    TInt iDriveNumber;
    };



class RBlockTargetMedia: public RTargetMedia
    {
public:
    RBlockTargetMedia(TInt aDriveNumber);
    void OpenL();
    TInt WriteBlock(TLba aLba);
    TInt ReadBlock(TLba aLba);

private:
    TBuf8<KBlockSize> iBlockData;
    };


class TTargetTestArea
    {
public:
    TTargetTestArea(RTargetMedia& aMedia);
    void CreateControlFile();
    void RemoveControlFile();
    void FindBlockStartL();

    TInt WriteBlockL(TBuf8<KBlockSize>& aBlock);
    TInt ReadBlockL(TBuf8<KBlockSize>& aBlock);
private:
    RTargetMedia& iTargetMedia;
    TInt iStartLba;
    };



class RTargetDrive: public RTargetMedia
    {
public:
    RTargetDrive(TInt aDriveNumber);
    TInt OpenTestAreaL(const TDesC8& aData);

    TInt Verify();
    TInt VerifyBlock(TLba aLba, TLba aBlocks);
    TInt Verify(TInt aPos, TUint aLen);

    TInt Update(TInt aPos, TUint aLen);

private:
    TPos StartPos() const;
    TPos TargetPos(TInt aPos) const;

private:
    TLba iStartLba;
    TPtrC8 iSource;
    TBuf8<KSize> iTmpBuffer;
    };


class CBlockDeviceTester: public CBase
	{
public:
    static CBlockDeviceTester* NewL(TInt aDriveNumber);
    ~CBlockDeviceTester();
protected:
    void ConstructL();
    CBlockDeviceTester(TInt aDriveNumber);

public:
    void OpenDriveL();
    void CloseDrive();

    TInt Update(TPos aPos, TUint aLen);
    TInt UpdateBlock(TLba aLba, TLba aBlocks);

    TInt VerifyDrive();
    TInt Verify(TPos aPos, TUint aLen);
    TInt VerifyBlock(TLba aLba, TLba aBlocks);

protected:
    // The drive parameters
    TInt iDriveNumber;
    TInt iDriveSizeInBlocks;

    // Local buffer
    TLocalBuffer iLocalBuffer;
    // The buffer on remote drive
    RTargetDrive iTargetDrive;
	};



class CBotTester: public CBlockDeviceTester
    {
public:
    enum TTestCase
        {
        ETestCaseTagMismatch = 1,
        ETestCaseInvalidSignature = 2,
        // No Data
        ETestCaseNoDataStallCsw = 3,
        ETestCaseNoDataPhaseError = 4,
        // Data OUT
        ETestCaseDoStallCsw = 5,
        ETestCaseDoStallData = 6,
        ETestCaseDoPhaseError = 7,
        ETestCaseDoResidue = 8,
        // Data IN
        ETestCaseDiStallCsw = 9,
        ETestCaseDiStallData = 0xA,
        ETestCaseDiPhaseError = 0xB,
        ETestCaseDiResidue = 0xC,
        // End
        ETestCaseNotSet
        };

    static const TPos KSetTestPos = 0x1000;
    static const TPos KWriteEnableFilePos = 0x2000;
    static const TPos KReadEnableFilePos = 0x3000;
    static const TPos KSenseErrorFile = 0x4000;

public:
    static CBotTester* NewL(TInt aDriveNumber);
    virtual ~CBotTester();
private:
    void ConstructL();
    CBotTester(TInt aDriveNumber);

public:
    TInt SetTest(TTestCase aTestCase);
    TInt WriteEnableFile();
    TInt InitReadEnableFile();
    TInt ReadEnableFile();

private:
    /**
    Place this buffer on block boundary and make buffers multiple of block size
    to avoid crossing block boundary
    */
    static const TInt KCmdBufferSize = KBlockSize;
    static const TInt KOutEnableBufferSize = KBlockSize * 4;
    static const TInt KInEnableBufferSize = KBlockSize * 4;

    TBuf8<KCmdBufferSize> iCmdBuffer;
    TBuf8<KOutEnableBufferSize> iOutEnableBuffer;
    TBuf8<KInEnableBufferSize> iInEnableBuffer;
    };


class CSbcErrTester: public CBlockDeviceTester
    {
public:
    enum TTestSenseError
        {
        ETestSenseErrorNoSense = 0,
        ETestSenseErrorMediaNotPresent = 1,
        ETestSenseErrorUnitAttention = 2
        };


    static const TPos KSetTestPos = 0x1000;
    static const TPos KWriteTestFilePos = 0x2000;
    static const TPos KReadTestFilePos = 0x3000;
    static const TPos KSenseErrorFile = 0x4000;

public:
    static CSbcErrTester* NewL(TInt aDriveNumber);
    virtual ~CSbcErrTester();
private:
    void ConstructL();
    CSbcErrTester(TInt aDriveNumber);

public:
    TInt WriteTestFile();
    TInt ReadTestFile();

    TInt WriteSenseErrorFile(TTestSenseError aTestSenseError);

private:
    /**
    Place this buffer on block boundary and make buffers multiple of block size
    to avoid block overlap
    */
    static const TInt KCmdBufferSize = KBlockSize;
    static const TInt KEnableBufferSize = KBlockSize * 4;
    static const TInt KSenseErrorBufferSize = KBlockSize * 4;

    TBuf8<KCmdBufferSize> iCmdBuffer;
    TBuf8<KEnableBufferSize> iEnableBuffer;
    TBuf8<KSenseErrorBufferSize> iSenseErrorBuffer;
    };



class CWrPrTester: public CBase
    {
public:
    static CWrPrTester* NewL(TInt aDriveNumber);
    virtual ~CWrPrTester();
private:
    void ConstructL();
    CWrPrTester(TInt aDriveNumber);

public:
    void SetWriteProtectL();
    void ClrWriteProtectL();
    TInt SetRemovableL();
    TInt ClrRemovableL();
    TInt WriteReadTestL();

private:
    enum TTestConfig
        {
        // Configure Media Write Protect Bit
        ETestConfigMediaWpClr = 1,
        ETestConfigMediaWpSet = 2,
        // Configure Media Removable flag
        ETestConfigMediaRmbClr = 3,
        ETestConfigMediaRmbSet = 4
        };

private:
    static const TPos KCmdPos = 0;
    static const TInt KCmdBufferSize = KBlockSize;
    TBuf8<KCmdBufferSize> iCmdBuffer;
    TBuf8<KCmdBufferSize> iInCmdBuffer;

    RTargetMedia iTargetMedia;

    TTargetTestArea iTargetTestArea;
    };


#include "cblockdevicetester.inl"

#ifdef XXX
inline TPos TLocalBuffer::TargetStartPos() const
    {
    return static_cast<TInt64>(iStartLba) * KBlockSize;
    }

inline TPos TLocalBuffer::TargetPos(TPos aPos) const
    {
    return TargetStartPos() + aPos;
    }
#endif

#endif // CBLOCKDEVICETESTER_H