// Copyright (c) 1998-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\server\t_chlffs.cpp
// 
//

#define __E32TEST_EXTENSION__
#include <f32file.h>
#include <e32test.h>
#include <e32hal.h>
#include <hal.h>

// Now non-t_main programs need to chk if they are running on lffs,
#include "t_server.h"
#include "t_chlffs.h"


const TInt KInvalidDriveLetter=-1;

LOCAL_D TInt LFFSdriveNumber=KInvalidDriveLetter;
LOCAL_D TBool LFFSTesting=EFalse;
_LIT(KLFFSName,"Lffs");


LOCAL_C void FormatLFFS(RFs &anFsSession,TDes &aDrive)
//
// Format the LFFS drive
//
	{
    RFormat format;
    TInt count;
    TInt r;
    
    test.Printf(_L("Format LFFS drive %S\r\n"), &aDrive);
    r=format.Open(anFsSession,aDrive,EHighDensity,count);
    test.Printf(_L("Format open done. Count = %d\r\n"), count);
    test(r==KErrNone);
    
    while (count)
		{
        TInt r=format.Next(count);
    	test.Printf(_L("Format next done. Count = %d\r\n"), count);
        test(r==KErrNone);
    	}
    
    format.Close();
	}

GLDEF_C TBool IsFileSystemLFFS(RFs &aFsSession,TInt aDrive)
//
// return true if lffs on aDrive
//
	{
	TFileName f;
	TInt r=aFsSession.FileSystemName(f,aDrive);
	test(r==KErrNone || r==KErrNotFound);
	return (f.CompareF(KLFFSName)==0);
	}

GLDEF_C TInt CheckLFFSDriveForPlatform()
//
// Check the LFFS drive number for the current platform
//
	{
	TInt lffsDrvNum;

	TInt uid;
    TInt r=HAL::Get(HAL::EMachineUid,uid);
    test(r==KErrNone);
    
    if (uid==HAL::EMachineUid_Brutus)
		{
        lffsDrvNum=EDriveK;
    	test.Printf(_L("Test is running on BRUTUS\r\n"));
		}
    else if (uid==HAL::EMachineUid_Win32Emulator)
		{
        lffsDrvNum=EDriveW;
    	test.Printf(_L("Test is running on WINS Pc\r\n"));
		}
	else if (uid == HAL::EMachineUid_Integrator)
		{
		lffsDrvNum=EDriveK;
		test.Printf(_L("Test is running on INTEGRATOR\r\n"));
		}
	else if (uid == HAL::EMachineUid_Assabet)
		{
		lffsDrvNum=EDriveK;
		test.Printf(_L("Test is running on Assabet\r\n"));
		}
    else
		lffsDrvNum=KInvalidDriveLetter;
	return(lffsDrvNum);
	}

GLDEF_C TBool CheckMountLFFS(RFs &anFsSession,TChar aDriveLetter)
//
// Check if test to be performed on LFFS drive. Mount the ELFFS.FSY if
// necessary
//
	{

    test.Next(_L("Check if LFFS drive (Mount LFFS if required)"));

	TInt r,drvNum;
	TBuf<4> lffsDriveLetter=_L("?:\\");

	// first check if the lffs is mounted on the drive
	r=anFsSession.CharToDrive(aDriveLetter,drvNum);
	test(r==KErrNone);
	if (IsFileSystemLFFS(anFsSession,drvNum))
		{
		lffsDriveLetter[0]=(TText)aDriveLetter;
		test.Printf(_L("Testing an LFFS drive (%S)"), &lffsDriveLetter);
		test.Printf(_L("LFFS already mounted on drive %S\r\n"), &lffsDriveLetter);
		LFFSdriveNumber=drvNum;
		LFFSTesting=ETrue;
		return(ETrue);
		}

	// check if platform expects lffs to be mounted on specified drive 
	TInt lffsDrvNum=CheckLFFSDriveForPlatform();
	if (drvNum!=lffsDrvNum)
		{
        test.Printf(_L("Not testing an LFFS drive\n"));
        return(EFalse);
    	}

	lffsDriveLetter[0]=(TText)aDriveLetter;
    test.Printf(_L("Testing an LFFS drive (%S)"), &lffsDriveLetter);
	LFFSdriveNumber=lffsDrvNum;
	LFFSTesting=ETrue;

    test.Next(_L("Load device driver: MEDLFS"));
    r=User::LoadPhysicalDevice(_L("MEDLFS"));
    test(r==KErrNone || r==KErrAlreadyExists);
    
    test.Next(_L("Add file system: ELFFS"));
    r=anFsSession.AddFileSystem(_L("ELFFS"));
    test(r==KErrNone || r==KErrAlreadyExists);
    
    TFullName name;
    r=anFsSession.FileSystemName(name,LFFSdriveNumber);
    test(r==KErrNone || r==KErrNotFound);

    if (name.MatchF(_L("Lffs")) != 0)
		{
        // Some other file system is at the "Lffs" drive. 
        if (name.Length() != 0)
			{
			// Not allowed to dismount the file system from the drive associated
			// with the default path - so temporarily change the default path.
            test.Printf(_L("Dismounting %S on drive %S\r\n"), &name, &lffsDriveLetter);
            r=anFsSession.DismountFileSystem(name,LFFSdriveNumber);
            test(r==KErrNone);

			}
    
        test.Printf(_L("Mount LFFS on drive %S\r\n"),&lffsDriveLetter);
        r=anFsSession.MountFileSystem(_L("Lffs"), LFFSdriveNumber);
        test.Printf(_L("  Mount result %d\r\n"), r);
        test(r==KErrNone || r==KErrCorrupt || r==KErrNotReady);
    
        if (r==KErrCorrupt)
			{
            test.Printf(_L("The volume was corrupt. Formatting...\r\n"));
            FormatLFFS(anFsSession,lffsDriveLetter);
        	}
        else if(r==KErrNotReady)
			{
            test.Printf(_L("The mount was not ready. Formatting...\r\n"));
            FormatLFFS(anFsSession,lffsDriveLetter);
        	}
        else
			{
            test.Printf(_L("The volume was mounted OK. Formatting...\r\n"));
            FormatLFFS(anFsSession,lffsDriveLetter); // ???
        	}
    	}
    else
		{
        test.Printf(_L("LFFS already mounted on drive %S\r\n"), &lffsDriveLetter);
    	}
    
    return(ETrue);
	}

GLDEF_C TBool IsTestingLFFS()
//
// Return ETrue if testing LFFS
//
	{
    return(LFFSTesting);
	}

GLDEF_C void TestingLFFS(TBool aSetting)
//
// Set whether testing LFFS or not
//
	{
    LFFSTesting=aSetting;
	}

GLDEF_C TInt GetDriveLFFS()
//
// Return the LFFS drive number
//
	{
    return(LFFSdriveNumber);
	}

GLDEF_C TBool IsSessionDriveLFFS(RFs& aFs,TChar& aDriveLetter)
	{
//
// Quick method of testing if session drive is LFFS
//	
	TBool isLffs;
	TFileName path;
	TInt r=aFs.SessionPath(path);
	test(r==KErrNone);
	TInt drv;
	r=RFs::CharToDrive(path[0],drv);
	test(r==KErrNone);

	aDriveLetter=path[0];
	isLffs=IsFileSystemLFFS(aFs,drv);
	if(isLffs)
		return(ETrue);

	// check if platform expects lffs to be mounted on default drive
	TInt lffsDrv = CheckLFFSDriveForPlatform();
	if (lffsDrv == KInvalidDriveLetter)
		{
		test.Printf(_L("IsSessionDriveLFFS: platform does not support lffs.\r\n"));
		isLffs = EFalse;
		}
	else
		{
		TChar curCh=path[0];
		curCh.LowerCase();

		TChar lffsCh;								// lffs drv ltr
		test((r = RFs::DriveToChar(lffsDrv, lffsCh)) == KErrNone);
		lffsCh.LowerCase();
		
		test.Printf(_L("IsSessionDriveLFFS: cur drv = \'%c\', lffs drv = \'%c\'.\n"), (TText) curCh, (TText) lffsCh);
		isLffs = ((TText) curCh) == ((TText) lffsCh);
		}

	return(isLffs);
	}

GLDEF_C TBool IsDefaultDriveLFFS()
//
// Quick method of testing if running on LFFS for non t_main based tests.
// 
	{
	// check if lffs mounted on default drive
	TBool isLffs;
	RFs fs;
	TInt r=fs.Connect();
	test(r==KErrNone);
	TFileName path;
	r=fs.SessionPath(path);
	test(r==KErrNone);
	TInt drv;
	r=TheFs.CharToDrive(path[0],drv);
	test(r==KErrNone);

	isLffs=IsFileSystemLFFS(fs,drv);
	fs.Close();
	if(isLffs)
		return(ETrue);

	// check if platform expects lffs to be mounted on default drive
	TInt lffsDrv = CheckLFFSDriveForPlatform();
	if (lffsDrv == KInvalidDriveLetter)
		{
		test.Printf(_L("IsCurrentDriveLFFS: platform does not support lffs.\r\n"));
		isLffs = EFalse;
		}
	else
		{
		TChar curCh=path[0];
		curCh.LowerCase();

		TChar lffsCh;								// lffs drv ltr
		test((r = RFs::DriveToChar(lffsDrv, lffsCh)) == KErrNone);
		lffsCh.LowerCase();
		
		test.Printf(_L("IsCurrentDriveLFFS: cur drv = \'%c\', lffs drv = \'%c\'.\n"), (TText) curCh, (TText) lffsCh);
		isLffs = ((TText) curCh) == ((TText) lffsCh);
		}

	return(isLffs);
	}

GLDEF_C TBool IsNamedDriveLFFS(RFs &aFsSession,TText aDrv)
//
// Quick method of testing if running on LFFS for non t_main based tests.
// 
	{
	TInt d;
	TInt r=RFs::CharToDrive(aDrv,d);
	test(r==KErrNone);
	return(IsFileSystemLFFS(aFsSession,d));
	}

GLDEF_C TInt GetLFFSControlModeSize()
//
// For LFFS, the media may not exhibit a contiguous data region. This is the case if the 
// Control Mode Size is non-zero.
//
	{
	TLocalDriveCapsV7 caps;		// V7 to allow for devices exhibiting Control Mode
	TPckg<TLocalDriveCapsV7> capsPckg(caps);
	TBusLocalDrive localDrive;
	TBool lffsMediaFound = EFalse;
	TBool dumBool = EFalse;		// Arbitrary if LFFS is mounted on non-removable media
	// Loop to find the local drive for LFFS - this is always of type EMediaFlash
	for(TInt drvNum=0; drvNum<KMaxLocalDrives; drvNum++)
		{
		TInt r=localDrive.Connect(drvNum,dumBool);
		if(r==KErrNotSupported)
			continue;		// Local drive not present
		test_KErrNone(r);
		r=localDrive.Caps(capsPckg);
		localDrive.Disconnect();
		if(r==KErrNotSupported||r==KErrNotReady)
			continue;		// Local drive not available
		test_KErrNone(r);
		if(capsPckg().iType==EMediaFlash)
			{
			lffsMediaFound=ETrue;
			break;
			}
		}
	if(!lffsMediaFound)
		{
		test.Printf(_L("GetLFFSControlModeSize: LFFS media not found !\n"));
		return KErrGeneral;
		}
	return (capsPckg().iControlModeSize);
	}