// 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);
	}