// Copyright (c) 2005-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:

// f32test\ext\t_testext.cpp

// 

//

#include <e32math.h>

#include "t_testext.h"

CTestProxyDrive::CTestProxyDrive(CProxyDrive* aProxyDrive, CMountCB* aMount)

    : CBaseExtProxyDrive(aProxyDrive,aMount), iMount(aMount)

    {

    __PRINT(_L("CTestProxyDrive::CTestProxyDrive"));

    }

CTestProxyDrive::~CTestProxyDrive()

    {

    __PRINT(_L("CTestProxyDrive::~CTestProxyDrive"));

    delete[] iMap;

    }

void CTestProxyDrive::InitL()

    {

    __PRINT(_L("CTestProxyDrive::Init"));

    DoInitL();

    // Allocate bad sector bit map

    TInt size = (iTotalSectors+7) >> 3; // round up by byte

    iMap = new(ELeave) TUint8[size];

    Mem::FillZ(iMap, size);

    iMountInitialised = ETrue;

    }

TInt CTestProxyDrive::ControlIO(const RMessagePtr2& aMessage,TInt aCommand,TAny* aParam1,TAny* aParam2)

    {

    __PRINT(_L("CTestProxyDrive::ControlIO"));

    TInt r = KErrNone;

    if (!iMountInitialised)

        return KErrNotReady;

    switch(aCommand+EExtCustom)

        {

        case ESetEvent:

            r = SetEvent((TInt)aParam1, (TInt)aParam2);

            break;

        case EMark:

            //-- mark given sector as bad

            __PRINT1(_L("CTestProxyDrive: marking sector:%d as bad"), (TInt)aParam1);

            r = Mark((TInt)aParam1);

            break;

        case EUnmark:

            //-- mark given sector as good

            __PRINT1(_L("CTestProxyDrive: Unmarking sector:%d"), (TInt)aParam1);

            r = Unmark((TInt)aParam1);

            break;

        case EUnmarkAll:

            r = UnmarkAll();

            break;

        case EIsMarked:

            if (IsMarked((TInt)aParam1))

                r = aMessage.Write(3, TPckgBuf<TBool>(ETrue));

            else

                r = aMessage.Write(3, TPckgBuf<TBool>(EFalse));

            break;

        case EDiskSize:

            r = aMessage.Write(2, TPckgBuf<TInt64>(iMount->Size()));

            break;

        default:

            r = DoControlIO(aMessage,aCommand,aParam1,aParam2);

            __PRINT2(_L("Get unknown command %d error %d"), aCommand, r);

        }

    return r;

    }

TInt CTestProxyDrive::GetLastErrorInfo(TDes8 &aErrorInfo)

    {

    __PRINT(_L("CTestProxyDrive::GetLastErrorInfo"));

    TPckgBuf<TErrorInfo> errInfoBuf;

    errInfoBuf().iReasonCode = iLastErrorReason;

    errInfoBuf().iErrorPos = iSuccessBytes;

    aErrorInfo = errInfoBuf;

    return KErrNone;

    }

TInt CTestProxyDrive::SetEvent(TInt aType, TInt aValue)

    {

    __PRINT(_L("CTestProxyDrive::SetEvent"));

    switch (aType)

        {

        case ENone:

            break;

        case ENext:

            iEventType = aType;

            break;

        case ERandom:

            Mark((TInt)(Math::Random() / (TReal64)KMaxTUint) * iTotalSectors);

            break;

        case EDeterministic:

            iEventType = aType;

            if (aValue <= 0)

                return KErrArgument;

            iCount = aValue;

            break;

        default:

            return KErrArgument;

        }

    return KErrNone;

    }

/**

    mark aSector as a bad sector by adding it to the bad sectors map

    @param  aSector sector number to mark as bad

*/

TInt CTestProxyDrive::Mark(TInt aSector)

    {

    __PRINT1(_L("CTestProxyDrive::Mark %d"), aSector);

    if (aSector >= iTotalSectors)

        return KErrNone;

    if (aSector < 0)

        return KErrArgument;

    iMap[aSector>>3] = (TUint8)(iMap[aSector>>3] | (1<<(aSector & 7)));

    return KErrNone;

    }

TInt CTestProxyDrive::Unmark(TInt aSector)

//

// Remove bad cluster aValue from list.

//

    {

    __PRINT1(_L("CTestProxyDrive::Unmark %d"), aSector);

    if (aSector>=iTotalSectors || aSector<0)

        return KErrArgument;

    iMap[aSector>>3] = (TUint8)(iMap[aSector>>3] & ~(1<<(aSector & 7)));

    return KErrNone;

    }

TInt CTestProxyDrive::UnmarkAll()

//

// Clear all bad cluster marks.

//

    {

    __PRINT(_L("CTestProxyDrive::UnmarkAll"));

    Mem::FillZ(iMap, (iTotalSectors+7)>>3);

    return KErrNone;

    }

TBool CTestProxyDrive::IsMarked(TInt aSector) const

//

// Check if cluster number is in bad cluster list.

//

    {

    if (aSector>=iTotalSectors || aSector<0)

        return EFalse;

    const TBool bMarked = iMap[aSector>>3] & (1<<(aSector & 7));

    if(bMarked)

        {

        __PRINT1(_L("CTestProxyDrive::IsMarked %d"), aSector);

        }

    return bMarked ;

    }

TBool CTestProxyDrive::CheckEvent(TInt64 aPos, TInt aLength)

    {

    //__PRINT(_L("CTestProxyDrive::CheckEvent"));

    if (!iMountInitialised)

        return EFalse;

    return DoCheckEvent(aPos, aLength);

    }