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

// Implementation of generic finite state machine state

// 

//

/**

 @file

 @internalTechnology

*/

#include <f32file.h>

#include <testusbc.h>

#include "tstate.h"

#include "t_ms_main.h"

#include "scsicmdbuilder.h"

#include "cpropertywatch.h"

_LIT(KMsFs, "MassStorageFileSystem");

GLREF_D RFs fs;

GLREF_D TInt removalDrvNo;

GLREF_D TUint8 testLun;

GLDEF_D TBuf8<KCbwLength> cbwBuf; 

GLDEF_D TBuf8<KCswLength> cswBuf;

GLDEF_D TInt dCBWTag = 1234567;    // arbitrary, any number would do for this test.

GLDEF_D RDevTestUsbcClient usbcClient;

/**

Unmount FAT and mount MSFS.

@param driveNumber

*/

LOCAL_C void MountMsFs(TInt driveNumber)

	{

	test.Printf(_L("MountMsFs driveNumber=%d\n"), driveNumber); 

	TInt err = KErrNone;

	TFileName oldFs;

	err = fs.FileSystemName(oldFs, driveNumber);

	test.Printf(_L("FAT file system name %S; error code %d\n"), &oldFs, err);

	test(err == KErrNone || err == KErrNotFound);

	if(err==KErrNone)

		{

		test.Printf(_L("Unmounting FAT FS %S\n"), &oldFs); 

	    err = fs.DismountFileSystem(oldFs, driveNumber);

	   	test.Printf(_L("%S Dismount %c: %d\n"), &oldFs,'A' + driveNumber, err);

	    test(err == KErrNone);

		}

	test.Printf(_L("Mounting MSFS\n")); 

	err = fs.MountFileSystem(KMsFs, driveNumber);

	test.Printf(_L("MSFS Mount %c:   %d\n"), 'A' + driveNumber, err);

	}

/**

Unmount MSFS and mount FAT.

@param driveNumber

*/

LOCAL_C void UnmountMsFs(TInt driveNumber)

	{

	test.Printf(_L("UnmountMsFs driveNumber=%d\n"), driveNumber); 

	TInt err = fs.DismountFileSystem(KMsFs, driveNumber);

	test.Printf(_L("MSFS Dismount:%d\n"), err);

	test(err == KErrNone);

	err = fs.MountFileSystem(_L("FAT"), driveNumber);

   	test.Printf(_L("FAT Mount:    %d\n"), err);

	}

LOCAL_C TBool SendAndReceive(TInt aStatus = 0)

	{

    test.Printf(_L("SendAndReceive\n"));

    TRequestStatus status;

    usbcClient.HostWrite(status, EEndpoint1, cbwBuf, KCbwLength); 

    User::WaitForRequest(status);

    test(KErrNone == status.Int());

    // Read CSW

    test.Printf(_L("Reading CSW\n"));

    usbcClient.HostRead(status, EEndpoint2, cswBuf, KCswLength);

    User::WaitForRequest(status);

    test(KErrNone == status.Int());

    // Check dCSWTag

    TInt recvedCBWTag = extractInt(&cswBuf[4]);

    test(dCBWTag == recvedCBWTag);

    // Check bCSWStatus

    TInt bCSWStatus = cswBuf[KCswLength - 1];

    test.Printf(_L("CSW status: %d\n"), bCSWStatus);

    return(bCSWStatus == aStatus);

	}

//////////////////////////////////////////////////////////////

void

TDisconnected::MoveTo(TInt aStateId) const

	{

    switch (aStateId)

    	{

        case EUsbMsDriveState_Connecting:

            MoveToConnecting();

            break;

    	case EUsbMsDriveState_Connected:

    		MoveToConnected();

    		break;	

        default:

            test.Printf(_L("Cannot reach %d from %d\n"), GetStateId(), aStateId);

            test(EFalse);

    	}

	}

void

TDisconnected::MoveToConnecting() const

	{

    test.Printf(_L("Moving to connecting state\n"));

   	MountMsFs(removalDrvNo);	

	// send test unit ready message

	BuildTestUnitReady();

	createCBW(cbwBuf, ++dCBWTag, 0, 0, scsiCmdBuf, testLun);

	test(SendAndReceive(1));		// 1: the unit is not ready!

	}

void

TDisconnected::MoveToConnected() const

	{

    test.Printf(_L("Moving to connected state\n"));

   	MountMsFs(removalDrvNo);

	BuildTestUnitReady();

	createCBW(cbwBuf, ++dCBWTag, 0, 0, scsiCmdBuf, testLun);

	test(SendAndReceive(1));

	}

//////////////////////////////////////////////////////////////

void

TConnecting::MoveTo(TInt aStateId) const

	{

    switch (aStateId)

    	{

       	case EUsbMsState_Written:

           	MoveToWritten();

            break;

       	default:

           	test.Printf(_L("Cannot reach %d from %d\n"), GetStateId(), aStateId);

           	test(EFalse);

    	}

	}

void TConnecting::MoveToWritten() const

	{

	test.Printf(_L("Moving to written state\n"));

	// Mount MS file system 

	MountMsFs(removalDrvNo);

	BuildTestUnitReady();

	createCBW(cbwBuf, ++dCBWTag, 0, 0, scsiCmdBuf, testLun);

	test(SendAndReceive(1));

	// Write 1k bytes using testldd. 

	// 0x2A: opcode for write (10); 10: starting sector; 2: total sectors

	BuildReadWrite(0x2A, 10, 2);

	// 0: indicates host writing

	createCBW(cbwBuf, ++dCBWTag, KKiloBytes, 0, scsiCmdBuf, testLun);

    // Send write command

    test.Printf(_L("Sending CBW write cmd\n"));

    TRequestStatus status;

    usbcClient.HostWrite(status, EEndpoint1, cbwBuf, KCbwLength); 

    User::WaitForRequest(status);

    test(KErrNone == status.Int());

	// Write actual data. We don't care the contents.

    TBuf8<KKiloBytes> writeBuf;	

	writeBuf.SetLength(KKiloBytes);

	usbcClient.HostWrite(status, EEndpoint1, writeBuf, KKiloBytes); 

    User::WaitForRequest(status);

    test(KErrNone == status.Int());

    // Check CSW status

    // Read CSW

    test.Printf(_L("Reading CSW\n"));

    usbcClient.HostRead(status, EEndpoint2, cswBuf, KCswLength);

    User::WaitForRequest(status);

    test(KErrNone == status.Int());

    // Check dCSWTag

    TInt recvedCBWTag = extractInt(&cswBuf[4]);

    test(dCBWTag == recvedCBWTag);

    // Check bCSWStatus

    TInt bCSWStatus = cswBuf[KCswLength - 1];

    test.Printf(_L("CSW status: %d\n"), bCSWStatus);

    test(bCSWStatus == 0);	

	}

//////////////////////////////////////////////////////////////

void

TConnected::MoveTo(TInt aStateId) const

	{

    switch (aStateId)

    	{

       	case EUsbMsDriveState_Active:

           	MoveToActive();

            break;

       	default:

           	test.Printf(_L("Cannot reach %d from %d\n"), GetStateId(), aStateId);

           	test(EFalse);

    	}

	}

void

TConnected::MoveToActive() const

	{

    test.Printf(_L("Moving to active state\n"));

    // send prevent medium removal using testld

    // 1: prevent medium removal

    BuildMediumRemoval(1);

    createCBW(cbwBuf, ++dCBWTag, 0, 0, scsiCmdBuf, testLun);

	if(!SendAndReceive())

		{

		// Prevent Media Removal command not supported

		test.Printf(_L("Prevent Media Removal command not supported, issuing read instead\n"));

		// Read 1k bytes using testldd. 

		// 0x28: opcode for read (10); 10: starting sector; 2: total sectors

		BuildReadWrite(0x28, 10, 2);

		// 0x80: indicates host writing

		createCBW(cbwBuf, ++dCBWTag, KKiloBytes, 0x80, scsiCmdBuf, testLun);

		// Send read command

		test.Printf(_L("Sending CBW read cmd\n"));

		TRequestStatus status;

		usbcClient.HostWrite(status, EEndpoint1, cbwBuf, KCbwLength); 

		User::WaitForRequest(status);

		test(KErrNone == status.Int());

		// Read actual data. We don't care the contents.

		TBuf8<KKiloBytes> readBuf;	

		readBuf.SetLength(KKiloBytes);

		usbcClient.HostRead(status, EEndpoint2, readBuf, KKiloBytes); 

		User::WaitForRequest(status);

		test(KErrNone == status.Int());

		// Check CSW status

		// Read CSW

		test.Printf(_L("Reading CSW\n"));

		usbcClient.HostRead(status, EEndpoint2, cswBuf, KCswLength);

		User::WaitForRequest(status);

		test(KErrNone == status.Int());

		// Check dCSWTag

		TInt recvedCBWTag = extractInt(&cswBuf[4]);

		test(dCBWTag == recvedCBWTag);

		// Check bCSWStatus

		TInt bCSWStatus = cswBuf[KCswLength - 1];

		test.Printf(_L("CSW status: %d\n"), bCSWStatus);

		test(bCSWStatus == 0);

		}

	}

//////////////////////////////////////////////////////////////

void

TActive::MoveTo(TInt aStateId) const

	{

    switch (aStateId)

    	{

       	case EUsbMsDriveState_Locked:

           	MoveToLocked();

            break;

    	case EUsbMsDriveState_Disconnecting:

    		MoveToDisconnecting();

    		break;

       	default:

           	test.Printf(_L("Cannot reach %d from %d\n"), GetStateId(), aStateId);

           	test(EFalse);

    	}

	}

void

TActive::MoveToLocked() const

	{

    test.Printf(_L("Moving to locked state\n"));

    // To be implemented. Wait for lock defect fix

	}

void

TActive::MoveToDisconnecting() const

	{

    test.Printf(_L("Moving to disconnecting state\n"));

    // send allow medium removal using testld

    // 0: allow medium removal

    BuildMediumRemoval(0);

    createCBW(cbwBuf, ++dCBWTag, 0, 0, scsiCmdBuf, testLun);

	if(!SendAndReceive())

		test.Printf(_L("Prevent Media Removal command not supported, no need to allow\n"));

	// Now the state is connected, let's move to disconnecting state

	// by sending a stop unit command

	// 0: stop unit

	BuildStartStopUnit(0);

	createCBW(cbwBuf, ++dCBWTag, 0, 0, scsiCmdBuf, testLun);

	test(SendAndReceive());

	}

//////////////////////////////////////////////////////////////

void

TLocked::MoveTo(TInt aStateId) const

	{

    switch (aStateId)

    	{

       	case EUsbMsDriveState_Disconnecting:

           	MoveToDisconnecting();

            break;

       	default:

           	test.Printf(_L("Cannot reach %d from %d\n"), GetStateId(), aStateId);

           	test(EFalse);

    	}

	}

void

TLocked::MoveToDisconnecting() const

	{

    test.Printf(_L("Moving to disconnecting state\n"));

    // To be implemented once lock issue is resolved

	}

//////////////////////////////////////////////////////////////

void

TDisconnecting::MoveTo(TInt aStateId) const

	{

    switch (aStateId)

    	{

       	case EUsbMsDriveState_Disconnected:

           	MoveToDisconnected();

            break;

       	default:

           	test.Printf(_L("Cannot reach %d from %d\n"), GetStateId(), aStateId);

           	test(EFalse);

    	}

	}

void

TDisconnecting::MoveToDisconnected() const

	{

    test.Printf(_L("Moving to disconnected state\n"));

    UnmountMsFs(removalDrvNo);

	}

//////////////////////////////////////////////////////////////

void

TWritten::MoveTo(TInt aStateId) const

	{

    switch (aStateId)

    	{

       	case EUsbMsState_Read:

           	MoveToRead();

            break;

       	default:

           	test.Printf(_L("Cannot reach %d from %d\n"), GetStateId(), aStateId);

           	test(EFalse);

    	}

	}

void

TWritten::MoveToRead() const

	{

    test.Printf(_L("Moving to read state\n"));

	// Read 1k bytes using testldd. 

	// 0x28: opcode for read (10); 10: starting sector; 2: total sectors

	BuildReadWrite(0x28, 10, 2);

	// 0x80: indicates host writing

	createCBW(cbwBuf, ++dCBWTag, KKiloBytes, 0x80, scsiCmdBuf, testLun);

    // Send read command

    test.Printf(_L("Sending CBW read cmd\n"));

    TRequestStatus status;

    usbcClient.HostWrite(status, EEndpoint1, cbwBuf, KCbwLength); 

    User::WaitForRequest(status);

    test(KErrNone == status.Int());

	// Read actual data. We don't care the contents.

    TBuf8<KKiloBytes> readBuf;	

	readBuf.SetLength(KKiloBytes);

	usbcClient.HostRead(status, EEndpoint2, readBuf, KKiloBytes); 

    User::WaitForRequest(status);

    test(KErrNone == status.Int());

    // Check CSW status

    // Read CSW

    test.Printf(_L("Reading CSW\n"));

    usbcClient.HostRead(status, EEndpoint2, cswBuf, KCswLength);

    User::WaitForRequest(status);

    test(KErrNone == status.Int());

    // Check dCSWTag

    TInt recvedCBWTag = extractInt(&cswBuf[4]);

    test(dCBWTag == recvedCBWTag);

    // Check bCSWStatus

    TInt bCSWStatus = cswBuf[KCswLength - 1];

    test.Printf(_L("CSW status: %d\n"), bCSWStatus);

    test(bCSWStatus == 0);		

	}

//////////////////////////////////////////////////////////////

void

TRead::MoveTo(TInt aStateId) const

	{

    switch (aStateId)

    	{

       	case EUsbMsDriveState_Disconnected:

           	MoveToDisconnected();

            break;

       	default:

           	test.Printf(_L("Cannot reach %d from %d\n"), GetStateId(), aStateId);

           	test(EFalse);

    	}

	}

void

TRead::MoveToDisconnected() const

	{

    test.Printf(_L("Moving to disconnected state\n"));

    UnmountMsFs(removalDrvNo);

	}