// Copyright (c) 1997-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:
// e32test\pccd\t_medch.cpp
// Continuously generate media changes followesd by a remount of the peripheral bus controller.
// 
//

#define __E32TEST_EXTENSION__
#include <e32test.h>
#include <e32svr.h>
#include <hal.h>
#include "d_medch.h"

//#define __SOAK_TEST__				// Define to run until a key is pressed (Automatic tests only)
//#define __MANUAL_TEST__			// Define to allow manual control of the door/media
//#define __DEVICE_HAS_NO_DOOR__	// Define for devices that have no door (Manual tests only)

#if defined(__MANUAL_TEST__) && defined(__WINS__)
#define __DEVICE_HAS_NO_DOOR__
#endif

#if !defined(__MANUAL_TEST__) && defined(__DEVICE_HAS_NO_DOOR__)
#undef __DEVICE_HAS_NO_DOOR__
#endif

#if defined(__MANUAL_TEST__) && defined(__SOAK_TEST__)
#undef __SOAK_TEST__
#endif

#ifndef __SOAK_TEST__
#ifdef __WINS__
const TInt KMaxTestTime	=  5000000;	// Run the test for 5 seconds on emulator
#else
const TInt KMaxTestTime	= 10000000;	// Run the test for 10 seconds on target
#endif
#endif

#define MMC_PDD_NAME _L("MEDMMC")

const TInt KPowerUpTimeOut = 5000000; // Give the card 5 seconds to power up

const TUint KDriveAttMask = KDriveAttLocal | KDriveAttRom | KDriveAttRemote;
const TUint KMediaAttMask = KMediaAttVariableSize | KMediaAttDualDensity | KMediaAttLockable | KMediaAttLocked | KMediaAttHasPassword  | KMediaAttReadWhileWrite;

LOCAL_D	RTest test(_L("Media change test"));

LOCAL_D	TBusLocalDrive TheDrive;
LOCAL_D	RMedCh TheMediaChange;
LOCAL_D TRequestStatus TheMediaStatus;
LOCAL_D TBool TheChangedFlag;

LOCAL_C TInt FindDataPagingDrive()
/** 
Find the drive containing the swap partition.

@return		Local drive identifier or KErrNotFound if not found
*/
	{
	TInt drive = KErrNotFound;
	
	RLocalDrive	d;
	TBool change = EFalse;
	TLocalDriveCapsV5 driveCaps;
	TPckg<TLocalDriveCapsV5> capsPack(driveCaps);
	
	for(TInt i = 0; i < KMaxLocalDrives && drive < 0; ++i)
		{
		if(d.Connect(i, change) == KErrNone)
			{
			if(d.Caps(capsPack) == KErrNone)
				{
				if ((driveCaps.iMediaAtt & KMediaAttPageable) &&
					(driveCaps.iPartitionType == KPartitionTypePagedData))
					{
					drive = i;
					}
				}
			d.Close();
			}
		}
		
	if(drive == KErrNotFound)
		{
		test.Printf(_L("No data paging drive found\n"));
		}
		
	return drive;
	}
	
LOCAL_C TInt DataPagingMediaCaps(TLocalDriveCapsV5 &aCaps)
/** 
Return the caps of the media containing a swap partition.

@return		Error code, on success aCaps contains the capabilities of the paging drive
*/
	{
	TInt dataPagingDrive = FindDataPagingDrive();
	
	if (dataPagingDrive == KErrNotFound)
		{
		return KErrNotFound;
		}

	RLocalDrive	dpDrive;
	TBool change = EFalse;

	TInt r = dpDrive.Connect(dataPagingDrive, change);
	test(r == KErrNone);
	
	TLocalDriveCapsV5 dpDriveCaps;
	TPckg<TLocalDriveCapsV5> capsPack(dpDriveCaps);
	r = dpDrive.Caps(capsPack);
	test(r == KErrNone);
	
	if((dpDriveCaps.iDriveAtt & KDriveAttHidden) == 0)
		{
		test.Printf(_L("Paging partition is not hidden! Assuming it is correct anyway!\n"));
		}
	
	aCaps = dpDriveCaps;
	
	return KErrNone;
	}
	
LOCAL_C TBool IsDriveOnPagingMedia(TInt aDrive, TLocalDriveCapsV5 &aPagingMediaCaps)
/** 
Determines whether a drive is on the same media as the paging media by comparing 
media characteristics

@return		ETrue if (likely) to be on the same media, EFalse if not.
*/	{
	RLocalDrive	drive;
	TBool change = EFalse;

	TInt r = drive.Connect(aDrive, change);
	test(r == KErrNone);
	
	TLocalDriveCapsV5 driveCaps;
	TPckg<TLocalDriveCapsV5> capsPack(driveCaps);
	r = drive.Caps(capsPack);
	test(r == KErrNone);
	
	// Check media serial number
	if(aPagingMediaCaps.iSerialNumLength > 0)
		{
		if((driveCaps.iSerialNumLength > 0) && 
		   ((memcompare(driveCaps.iSerialNum, driveCaps.iSerialNumLength, 
			aPagingMediaCaps.iSerialNum, aPagingMediaCaps.iSerialNumLength)) == 0))
			{
			// serial numbers equal, so drive in question is on same media as paging drive
			test.Printf(_L("Based on serial number match, drive %d shares the same media as paging drive\n"), aDrive);
			return ETrue;
			}
		}
	else
		{
		// Turn off bits which may be different
		aPagingMediaCaps.iDriveAtt &= KDriveAttMask;
		aPagingMediaCaps.iMediaAtt &= KMediaAttMask;
		driveCaps.iDriveAtt &= KDriveAttMask;
		driveCaps.iMediaAtt &= KMediaAttMask;

		if ((driveCaps.iType == aPagingMediaCaps.iType) &&
			(driveCaps.iDriveAtt == aPagingMediaCaps.iDriveAtt) && 
			(driveCaps.iMediaAtt == aPagingMediaCaps.iMediaAtt))
			{
			test.Printf(_L("Based on media characteristics match, drive %d shares the same media as paging drive\n"), aDrive);
			return ETrue;
			}
		}
		
	return EFalse;
	}


LOCAL_C TBool SetupDrivesForPlatform(TInt& aDrive, TInt& aSocket)
/**
 * Finds a suitable drive for the media change test
 *
 * @param aDrive  The number of the local drive to test
 * @param aSocket The number of the socket to test
 * @return TBool ETrue if a suitable drive is found, EFalse otherwise.
 */
	{
	
	TDriveInfoV1Buf diBuf;
	UserHal::DriveInfo(diBuf);
	TDriveInfoV1 &di=diBuf();

	aDrive  = -1;
	aSocket = -1;
	
	TLocalDriveCapsV5 pagingMediaCaps;
	TBool pagingMediaCheck = EFalse;
	if(DataPagingMediaCaps(pagingMediaCaps) == KErrNone)
		{
		pagingMediaCheck = ETrue;
		}
	
	for(aDrive=0; aDrive < di.iTotalSupportedDrives; aDrive++)
		{
		test.Printf(_L(" Drive %d - %S\r\n"), aDrive, &di.iDriveName[aDrive]);
		if(di.iDriveName[aDrive].MatchF(_L("MultiMediaCard0")) == KErrNone)
			{
			if(pagingMediaCheck)
				{
				if( ! IsDriveOnPagingMedia(aDrive, pagingMediaCaps))
					{
					break;
					}
				}
			}
		}

	if(aDrive == di.iTotalSupportedDrives)
		{
		test.Printf(_L(" MMC Drive Not Found\r\n"));
		return EFalse;
		}
		
	
	for(aSocket=0; aSocket < di.iTotalSockets; aSocket++)
		{
		test.Printf(_L("Socket %d - %S\r\n"), aSocket, &di.iSocketName[aSocket]);
		if(di.iSocketName[aSocket].MatchF(_L("MultiMediaCard0")) == KErrNone)
			break;
		}

	if(aSocket == di.iTotalSockets)
		{
		test.Printf(_L(" MMC Socket Not Found\r\n"));
		return EFalse;
		}

	return ETrue;
	}

LOCAL_C void TestMediaAccess(TInt aExpectedError, TBool aExpectedChange)
/**
 * Tests that the drive is accessable (or not) by issuing a request 
 * to power up the media.  Also verifies that the attributes are correct.
 * 
 * @param aExpectedError The expected result of powering up the drive
 * @param aExpectedChange ETrue if the changed flag is expected to be set
 *
 * @return ETrue if successful, EFalse otherwise
 */
	{
	
	RTimer rto;
	TInt r = rto.CreateLocal();
	test(r == KErrNone);
	
	TRequestStatus rtoStat;
	rto.After(rtoStat, KPowerUpTimeOut);
	test(rtoStat == KRequestPending);
	
	if(aExpectedChange)
		{
		// TheChangedFlag is set when the door is opened if media was present.
		// The asynch notifier is signalled when media is removed OR inserted.
		User::WaitForRequest(TheMediaStatus, rtoStat);
		test(TheMediaStatus != KRequestPending);
		}

	// ...aChangedFlag's purpose is to notify us of media removal.
	test_Equal(aExpectedChange,TheChangedFlag);

	TheDrive.NotifyChange(&TheMediaStatus);
	TheChangedFlag = EFalse;

	// Attempt to power up the drive
	TLocalDriveCapsV2Buf info;
	do
		{
		r = TheDrive.Caps(info);
		}
	while(r != aExpectedError && rtoStat == KRequestPending);

	rto.Cancel();
	rto.Close();

	// ...was the error as expected?
	test(r == aExpectedError);

	// ...and are the caps still OK?
	if(r == KErrNone)
		test(info().iType == EMediaHardDisk);
	else if(r == KErrNotReady)
		test(info().iType == EMediaNotPresent);

	if(aExpectedChange == EFalse)
		test(TheMediaStatus == KRequestPending);
	}

LOCAL_C void NextTest(const TDesC& aTitle, TInt aCycles)
/**
 * Simply displays a string on the console and the current iteration.
 * 
 * @param aTitle  The text to be displayed
 * @param aCycles The current iteration
 */
	{
	test.Console()->SetPos(20, 25);
	test.Printf(_L("%S [%d cycles]\n"), &aTitle, aCycles);
#ifdef __MANUAL_TEST__
	test.Console()->SetPos(20, 27);
	test.Printf(_L("<press a key>\n"));
	test.Getch();
#endif
	}

GLDEF_C TInt E32Main()
/**
 * Test Entry Point for T_MEDCH.
 * 
 * This test uses the associated driver (D_MEDCH) to simulate media removal and 
 * door opening/closing.  The media is powered up in each state and verified that 
 * the correct error code and changed count is returned.
 */
    {
	TBuf<64> b;
	test.Title();

	/**
	 * Load the associated media driver (MEDMMC by default).  This is required to ensure 
	 * that the device can be powered up and the capabilities if the media accessed.
	 */
	test.Start(_L("Load Media Driver"));
	TInt r;
	r=User::LoadPhysicalDevice(MMC_PDD_NAME);
	if(r==KErrNotFound)
		{
		test.Printf(_L("Test not supported on this platform \n"));
		test.End();
		return(0);
		}
	test(r==KErrNone || r==KErrAlreadyExists);

	/**
	 * Connect to the required local drive.
	 * TheChangedFlag is used for detection of media removal.
	 */
	TInt drive;
	TInt socket;

	if(SetupDrivesForPlatform(drive, socket))
		{
		b.Format(_L("Connect to local drive %d"), drive);
		test.Next(b);
		TheDrive.Connect(drive, TheChangedFlag);
	
		/**
		 * Read the drive capabilities to ensure that this test may be run.
		 */
		test.Next(_L("Get drive capabilities"));
		TLocalDriveCapsV2Buf info;
		r = TheDrive.Caps(info);
		if(r == KErrNotReady || r == KErrNotSupported)
			{
			test.Next(_L("\r\nTest requires media to be present and the door closed - Disconnecting"));
			TheDrive.Disconnect();		
			test.End();
			return KErrNone;
			}	
		test(r == KErrNone);
	
		test(TheDrive.Caps(info) == KErrNone);
		test(info().iType == EMediaHardDisk);
	
		/**
		 * Load the media simulation test driver
		 */
		test.Next(_L("Load media change logical device"));
		r=User::LoadLogicalDevice(_L("D_MEDCH"));
		test(r == KErrNone || r == KErrAlreadyExists);
	
		test.Next(_L("Open device"));
		r=TheMediaChange.Open(socket, TheMediaChange.VersionRequired());
		if(r == KErrNotSupported)
			{
			test.Next(_L("\r\nTest not supported on this drive - Disconnecting"));
			r=User::FreeLogicalDevice(_L("MedCh"));
			test(r == KErrNone);
			TheDrive.Disconnect();
			test.End();
			return KErrNone;
			}	
		test(r == KErrNone);
	
		/**
		 * Verify that the system supports simulation of media change events
		 */
		test.Next(_L("Test support for media change simulation"));
		r = TheMediaChange.DoorNormal();
		test(r == KErrNone || r == KErrNotSupported);
	
		/**
		 * Now for the real testing...
		 */
		if(r == KErrNone)
			{
			/**
	    	 * Test0 - Simulate 2 consecutive door open interrupts
			 */
			test.Next(_L("Test that the pbus can handle 2 consecutive door open interrupts"));
			TheDrive.NotifyChange(&TheMediaStatus);
			r = TheMediaChange.DoubleDoorOpen();
			test(r == KErrNone || r == KErrNotSupported);
			TestMediaAccess(KErrNone, ETrue);
		

			TInt cycles=0;
#if defined(__SOAK_TEST__)
			TRequestStatus endStat;
			test.Console()->Read(endStat);
			while(endStat == KRequestPending)
#elif !defined(__MANUAL_TEST__)
			RTimer t;
			r=t.CreateLocal();
			test(r == KErrNone);
			TRequestStatus endStat;
			t.After(endStat, KMaxTestTime);
			test(endStat == KRequestPending);
			while(endStat == KRequestPending)
#endif
				{
				TheChangedFlag = EFalse;
	
				TheDrive.NotifyChange(&TheMediaStatus);
	
				/**
	    		 * Test1 - Simulate door open
				 *		 - Power up responds with KErrNotReady
				 */
				NextTest(_L("Open Door......"), cycles);
#ifndef __MANUAL_TEST__
				test(TheMediaChange.DoorOpen() == KErrNone);
#endif
				TestMediaAccess(KErrNotReady, ETrue);
				TheDrive.NotifyChange(&TheMediaStatus);
	
				/**
	    		 * Test2 - Simulate door closed (with media removed)
				 *		 - Power up responds with KErrNotReady
				 */
#ifndef __DEVICE_HAS_NO_DOOR__
	    		NextTest(_L("Remove Media..."), cycles);
#ifndef __MANUAL_TEST__
				test(TheMediaChange.DoorClose(EFalse) == KErrNone);		
#endif
				TestMediaAccess(KErrNotReady, EFalse);					
				/**
	    		 * Test3 - Simulate door open
				 *		 - Power up responds with KErrNotReady
				 */
				NextTest(_L("Open Door......"), cycles);
#ifndef __MANUAL_TEST__
				test(TheMediaChange.DoorOpen() == KErrNone);			
#endif
				TestMediaAccess(KErrNotReady, EFalse);				// Power up responds with KErrNotReady
#endif
				/**
	    		 * Test4 - Simulate door closed (with media present)
				 *		 - Power up responds with KErrNone
				 */
	    		NextTest(_L("Insert Media..."), cycles);
#ifndef __MANUAL_TEST__
				test(TheMediaChange.DoorClose(ETrue) == KErrNone);
#endif
				TestMediaAccess(KErrNone, ETrue);
				++cycles;
				}
	
			test.Console()->SetPos(0, 27);
#if !defined(__SOAK_TEST__) && !defined(__MANUAL_TEST__)
			t.Close();
#endif
			}
		else if(r == KErrNotSupported)
			{
			test.Printf(_L("Media change simulation not supported"));
			}
	
		/**
		 * Tidy up and exit
		 */
		test.Next(_L("\r\nClose device"));
		TheMediaChange.Close();
	
		test.Next(_L("Free device"));
		r=User::FreeLogicalDevice(_L("MedCh"));
		test(r == KErrNone);
	
		b.Format(_L("\r\nDisconnect from local drive %d "), drive);
		test.Next(b);
		TheDrive.Disconnect();
		}

	test.End();
	return(0);
	}
  
