// Copyright (c) 2008-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 CMASSSTORAGEFSM_H
#define CMASSSTORAGEFSM_H

class CScsiProtocol;

/**
Wrapper for Mass Storage operations. Each action converts the response into a
TEvent value for use by the CMassStorageStateMachine.
*/
class TMassStorage: public CBase
    {
public:
    TMassStorage(CScsiProtocol& aScsiProtocol);

    /** FSM Events */
    enum TEvent
        {
        EEvCommandPassed,
        EEvCommandFailed,   // transport status error
        EEvCommandError     // stall or protocol error
        };

    // SCSI Commands
    TEvent InquiryL();
    TEvent SenseL();
    TEvent TestUnitReadyL();
    TEvent StartStopUnitL(TBool aStart);
    TEvent PreventAllowMediumRemovalL(TBool aPrevent);
    TEvent ReadCapacityL();
    TEvent ModeSense10L();
    TEvent ModeSense6L();

    // SCSI state
    TBool IsSbcSet() const;
    TBool IsRemovableMedia() const;
    const TSenseInfo& MsSenseInfo() const;

private:
    TEvent ErrToEvent(TInt err) const;

private:
    /** Reference to the actual interface */
    CScsiProtocol& iScsiProtocol;
    };


inline TMassStorage::TEvent TMassStorage::ErrToEvent(TInt err) const
    {
    if (err == KErrNone)
        return EEvCommandPassed;
    else if (err == KErrCommandFailed)
        return EEvCommandFailed;
    else // (KErrGeneral, KErrCommandStalled)
        return EEvCommandError;
    }


class CMassStorageFsm;


/**
Abstract class to represent state object. Each state object defines action to do
on entry and the next state to move to.
*/
class TMassStorageState
    {
public:
    friend class CMassStorageFsm;

    /** State ID */
    enum TStateId
        {
        // INQUIRY
        EInquiryState = 0,
        EInquirySenseState = 1,

        // TEST UNIT READY
        ENotReadyState = 2,
        ENotReadySenseState = 3,

        // START STOP UNIT
        EStartUnitState = 4,
        EStartUnitSenseState = 5,

        // PREVENT ALLOW MEDIUM REMOVAL
        EPreventRemovalState = 6,
        EPreventRemovalSenseState = 7,

        // READ CAPACITY 10
        EReadCapacityState = 8,

        // MODE SENSE 10
        EModeSense10State = 9,
        EModeSense10SenseState = 10,

        // MODE SENSE 6
        EModeSense6State = 11,
        EModeSense6SenseState = 12,

        // CONNECTED
        EConnectedState = 13,

        // STATUS CHECK
        EStatusCheckState = 14,

        // PREVENT ALLOW MEDIUM REMOVAL
        EAllowRemovalState = 15,

        // STOP UNIT
        EStopUnitState = 16,

        // REQUEST SENSE (common sense error handler)
        ESenseState = 17,

        //
        ENumberOfStates
        };

public:
    TMassStorageState(TStateId aStateId);

    /** State Entry */
    virtual TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm) = 0;

    /** Maps PASSED Event to next state */
    virtual TInt ScsiCommandPassed(CMassStorageFsm& aFsm) = 0;
    /** Maps FAILED event to next state */
    virtual TInt ScsiCommandFailed(CMassStorageFsm& aFsm) = 0;
    /** Maps ERROR event to next state */
    virtual TInt ScsiCommandError(CMassStorageFsm& aFsm);

protected:
    /** General event handler for a sense error event */
    TInt SenseError(CMassStorageFsm& aFsm);

private:
    /** State ID for state implentation */
    const TStateId iStateId;
    };



/**
State Machine to perform Mass STorage Connection and Disconnection
*/
class CMassStorageFsm: public TMassStorage
    {
public:
	static CMassStorageFsm* NewL(CScsiProtocol& aScsiProtocol);
	~CMassStorageFsm();

private:
    void ConstructL();
	CMassStorageFsm(CScsiProtocol& aScsiProtocol);

public:
    TInt ConnectLogicalUnitL();
    TInt DisconnectLogicalUnitL();

    TBool IsConnected() const;
	void  ClearStatusCheck();
	TBool IsStatusCheck() const;
	void  SetStatusCheck();

    void SetState(TMassStorageState::TStateId aStateId);

    void SetStartStopUnitRequired(TBool aRequired);
    TBool StartStopUnitRequired() const;

private:
    TInt ProcessStateL();


    // Event handlers
    TInt ScsiCommandPassed();
    TInt ScsiCommandFailed();
    TInt ScsiCommandError();

private:
    TMassStorage::TEvent EntryL();

private:
    TMassStorageState* iState;

    TFixedArray<TMassStorageState*, TMassStorageState::ENumberOfStates> iStateTable;

    TBool iStartStopUnitRequired;
	TBool iStatusCheck;
    };

/**
State that executes INQUIRY
*/
class TInquiryState: public TMassStorageState
    {
public:
    TInquiryState();
    TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm);

    TInt ScsiCommandPassed(CMassStorageFsm& aFsm);
    TInt ScsiCommandFailed(CMassStorageFsm& aFsm);
    };

/**
State that execute REQUEST SENSE after TInquiryState
*/
class TInquirySenseState: public TMassStorageState
    {
public:
    TInquirySenseState();
    TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm);
    TInt ScsiCommandPassed(CMassStorageFsm& aFsm);
    TInt ScsiCommandFailed(CMassStorageFsm& aFsm);
    };

/**
State that executes TEST UNIT READY
*/
class TNotReadyState: public TMassStorageState
    {
public:
    TNotReadyState();
    TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm);
    TInt ScsiCommandPassed(CMassStorageFsm& aFsm);
    TInt ScsiCommandFailed(CMassStorageFsm& aFsm);
    };


/**
State that executes REQUEST SENSE after TNotReadyState
*/
class TNotReadySenseState: public TMassStorageState
    {
public:
    TNotReadySenseState();
    TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm);
    TInt ScsiCommandPassed(CMassStorageFsm& aFsm);
    TInt ScsiCommandFailed(CMassStorageFsm& aFsm);
    };


/**
State that executes START STOP UNIT (start)
*/
class TStartUnitState: public TMassStorageState
    {
public:
    TStartUnitState();
    TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm);
    TInt ScsiCommandPassed(CMassStorageFsm& aFsm);
    TInt ScsiCommandFailed(CMassStorageFsm& aFsm);
    };

/**
State that executes REQUEST SENSE after TStartUnitState
*/
class TStartUnitSenseState: public TMassStorageState
    {
public:
    TStartUnitSenseState();
    TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm);
    TInt ScsiCommandPassed(CMassStorageFsm& aFsm);
    TInt ScsiCommandFailed(CMassStorageFsm& aFsm);
    };


/**
State that executes PREVENT MEDIA REMOVAL
*/
class TPreventMediumRemovalState: public TMassStorageState
    {
public:
    TPreventMediumRemovalState();
    TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm);
    TInt ScsiCommandPassed(CMassStorageFsm& aFsm);
    TInt ScsiCommandFailed(CMassStorageFsm& aFsm);
    };


/**
State that executes REQUEST SENSE from TPreventAllowMediumRemovalState
*/
class TPreventMediumRemovalSenseState: public TMassStorageState
    {
public:
    TPreventMediumRemovalSenseState();
    TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm);
    TInt ScsiCommandPassed(CMassStorageFsm& aFsm);
    TInt ScsiCommandFailed(CMassStorageFsm& aFsm);
    };


/**
State that execute READ CAPACITY (10) state
*/
class TReadCapacity10State: public TMassStorageState
    {
public:
    TReadCapacity10State();
    TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm);
    TInt ScsiCommandPassed(CMassStorageFsm& aFsm);
    TInt ScsiCommandFailed(CMassStorageFsm& aFsm);
    TInt ScsiCommandError(CMassStorageFsm& aFsm);
    };


/**
State that executes MODE SENSE (10) state
*/
class TModeSense10State: public TMassStorageState
    {
public:
    TModeSense10State();
    TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm);
    TInt ScsiCommandPassed(CMassStorageFsm& aFsm);
    TInt ScsiCommandFailed(CMassStorageFsm& aFsm);
    TInt ScsiCommandError(CMassStorageFsm& aFsm);
    };

/**
State that executes REQUEST SENSE from TModeSense10State
*/
class TModeSense10SenseState: public TMassStorageState
    {
public:
    TModeSense10SenseState();
    TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm);
    TInt ScsiCommandPassed(CMassStorageFsm& aFsm);
    TInt ScsiCommandFailed(CMassStorageFsm& aFsm);
    };

/**
State that executes MODE SENSE (6) state
*/
class TModeSense6State: public TMassStorageState
    {
public:
    TModeSense6State();
    TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm);
    TInt ScsiCommandPassed(CMassStorageFsm& aFsm);
    TInt ScsiCommandFailed(CMassStorageFsm& aFsm);
    TInt ScsiCommandError(CMassStorageFsm& aFsm);
    };


/**
State that executes REQUEST SENSE from TModeSense6State
*/
class TModeSense6SenseState: public TMassStorageState
    {
public:
    TModeSense6SenseState();
    TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm);
    TInt ScsiCommandPassed(CMassStorageFsm& aFsm);
    TInt ScsiCommandFailed(CMassStorageFsm& aFsm);
    };


/**
State that begins move from connected stae back to disconnected state
*/
class TConnectedState: public TMassStorageState
    {
public:
    TConnectedState();
    TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm);
    TInt ScsiCommandPassed(CMassStorageFsm& aFsm);
    TInt ScsiCommandFailed(CMassStorageFsm& aFsm);
    };

/**
State that executes TEST UNIT READY
*/
class TStatusCheckState: public TMassStorageState
    {
public:
    TStatusCheckState();
    TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm);
    TInt ScsiCommandPassed(CMassStorageFsm& aFsm);
    TInt ScsiCommandFailed(CMassStorageFsm& aFsm);
    };

/**
State that executes PREVENT ALLOW MEDIA REMOVAL
*/
class TAllowMediumRemovalState: public TMassStorageState
    {
public:
    TAllowMediumRemovalState();
    TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm);
    TInt ScsiCommandPassed(CMassStorageFsm& aFsm);
    TInt ScsiCommandFailed(CMassStorageFsm& aFsm);
    };


/**
State that executes START STOP UNIT
*/
class TStopUnitState: public TMassStorageState
    {
public:
    TStopUnitState();
    TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm);
    TInt ScsiCommandPassed(CMassStorageFsm& aFsm);
    TInt ScsiCommandFailed(CMassStorageFsm& aFsm);
    };

/**
State that executes REQUEST SENSE
*/
class TSenseState: public TMassStorageState
    {
public:
    TSenseState();
    TMassStorage::TEvent EntryL(CMassStorageFsm& aFsm);
    TInt ScsiCommandPassed(CMassStorageFsm& aFsm);
    TInt ScsiCommandFailed(CMassStorageFsm& aFsm);
    };


#include "cmassstoragefsm.inl"

#endif // CMASSSTORAGEFSM_H