// Copyright (c) 2006-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:

 // USB Mass Storage Application - also used as an improvised boot loader mechanism

 // 

 //

 /**

  @file

 */

 #include "usbmsapp.h"

 #include <e32std.h>

 #include <e32std_private.h>

 #include <e32svr.h>

 #include <e32cons.h>

 #include <f32file.h>

 #include <usbmsshared.h>

 #include <massstorage.h>

 TBool gSharedChunkLdd = EFalse;

 #include <d32usbcsc.h>

 #include <d32usbc.h>

 #ifdef BUILD_OTG_USBMSAPP

 #include <d32otgdi.h>

 #endif

 #include <nkern/nk_trace.h>

 #include <hal.h>

 #ifdef USB_BOOT_LOADER

 #include "usbbootvar.h"

 #include <rebootdrv.h>

 #define KNANDLDRLDD_NAME _L("REBOOT.LDD")

 static RReboot* RebootDrv;

 /// Global number of seconds to delay before reboot

 static TInt gRebootDelay = 0;

 #endif

 enum

 	{

 	EUsbDeviceStateUndefined  = EUsbcDeviceStateUndefined,

 	EUsbDeviceStateConfigured = EUsbcDeviceStateConfigured,

 	};

 static CConsoleBase* console = NULL;

 static RFs fs;

 static TInt selectedDriveIndex = 0;

 static TBuf<0x40> mountList;

 static TFixedArray<TBool, KMaxDrives>                   msfsMountedList;  ///< 'true' entry corresponds to the drive with mounted MSFS.FSY

 static TFixedArray<CFileSystemDescriptor*, KMaxDrives>  unmountedFsList;  ///< every non-NULL entry corresponds to the unmounted original FS for the drive

 _LIT(KMsFsy, "MSFS.FSY");

 _LIT(KMsFs, "MassStorageFileSystem");

 _LIT(KOk,"OK");

 _LIT(KError,"Error");

 _LIT(KBytesTransferredFmt, "%c:%d/%d ");

 _LIT(KErrFmt, "Error: %d\r");

 #ifndef USB_BOOT_LOADER

 _LIT(KTxtApp,"USBMSAPP");

 _LIT(KDefPwd,"123");

 #endif

 //-- if defined, some useful information will be printed out via RDebug interface

 //#define LOGGING_ENABLED

 //-----------------------------------------------------------------------------

 /** 

     prints a line to the console and copies it to the debug log if LOGGING_ENABLED

 */

 void LogPrint(TRefByValue<const TDesC> aFmt,...)

     {

     VA_LIST list;

     VA_START(list, aFmt);

     TBuf<0x100> buf;

 	// coverity[uninit_use_in_call]

     buf.FormatList(aFmt, list); //-- ignore overflows

     if(console)

         console->Write(buf);

 #ifdef LOGGING_ENABLED

     //-- print out the line via RDebug::Print 

     const TInt bufLen = buf.Length();

     if(bufLen >0 && buf[bufLen-1] == '\n')

         {

         buf.Insert(bufLen-1, _L("\r"));

         }

     else

         {

         buf.Append(_L("\r\n"));    

         }

     RDebug::RawPrint(buf);

 #endif

     }

 //-----------------------------------------------------------------------------

 /**

     prints a line to the debug log if LOGGING_ENABLED

 */

 void Log(TRefByValue<const TDesC> aFmt,...)

     {

 #ifdef LOGGING_ENABLED

     VA_LIST list;

     VA_START(list, aFmt);

     TBuf<0x100> buf;

     buf.FormatList(aFmt, list); //-- ignore overflows

     //-- print out the line via RDebug::Print 

     const TInt bufLen = buf.Length();

     if(bufLen >0 && buf[bufLen-1] == '\n')

         {

         buf.Insert(bufLen-1, _L("\r"));

         }

     RDebug::RawPrint(buf);

 #else

     (void)aFmt;

 #endif

     }

 //-----------------------------------------------------------------------------

 static void Clear(int row, int count=1)

 	{

 	_LIT(KBlank,"                                        ");

 	for(TInt i=0; i<count; i++)

 		{

 		console->SetPos(0,row+i);

 		console->Printf(KBlank);

 		}

 	console->SetPos(0,row);

 	}

 static void ShowDriveSelection()

 	{

 	console->SetPos(0,15);

 	if(PropertyHandlers::allDrivesStatus.Length()/2 > selectedDriveIndex)

 		{

 		LogPrint(_L("Selected Drive: %c"), 'A' + PropertyHandlers::allDrivesStatus[selectedDriveIndex*2]);

 		}

 	else

 		{

 		LogPrint(_L("Selected Drive: (none)"));

 		}

 	}

 #ifdef USB_BOOT_LOADER

 static void rebootit()

 	{

 	TInt r=User::LoadLogicalDevice(KNANDLDRLDD_NAME);

 	RebootDrv=new RReboot;

 	if(!RebootDrv)

 		{

 		User::Panic(_L("Loading driver"),1);

 		}

 	r=RebootDrv->Open();

 	if (r!=KErrNone)

 		{

 		User::Panic(_L("Opening driver"),r);

 		}

 	if (gRebootDelay>0)

 		{

 		_LIT(KMsgRebooting,"*** Reboot in %d secs ***\n");

 		TInt delay=gRebootDelay;

 		console->SetPos(0,20);

 			do

 			{

 			LogPrint(KMsgRebooting, delay);

 			User::After(1000000);

 			} while(--delay);

 		}

 	r=RebootDrv->VariantCtrl(KVariantUsbmsVariantRebootReason, NULL);

 	if (r!=KErrNone)

 		{

 		User::Panic(_L("Rebooting"),r);

 		}

 	}

 #endif

 class CPeriodUpdate : public CActive

 	{

 public:

 	static CPeriodUpdate* NewLC();

 private:

 	CPeriodUpdate();

 	void ConstructL();

 	~CPeriodUpdate();

 	void RunL();

 	void DoCancel();

 	RTimer iTimer;

 	TUint iUpTime;

 	};

 CPeriodUpdate* CPeriodUpdate::NewLC()

 	{

 	CPeriodUpdate* me=new(ELeave) CPeriodUpdate();

 	CleanupStack::PushL(me);

 	me->ConstructL();

 	return me;

 	}

 CPeriodUpdate::CPeriodUpdate()

 	: CActive(0), iUpTime(0)

 	{}

 void CPeriodUpdate::ConstructL()

 	{

 	CActiveScheduler::Add(this);

 	iTimer.CreateLocal();

 	RunL();

 	}

 CPeriodUpdate::~CPeriodUpdate()

 	{

 	Cancel();

 	}

 void CPeriodUpdate::DoCancel()

 	{

 	}

 void CPeriodUpdate::RunL()

 	{

 	SetActive();

 	// Print RAM usage & up time

 	iUpTime++;

 	TUint totmins=(iUpTime/60);

 	TUint tothrs=(totmins/60);

 	TInt mem=0;

 	if (HAL::Get(HALData::EMemoryRAMFree, mem)==KErrNone)

 		{

 		console->SetPos(0,22);

 		console->Printf(_L("mem (bytes) : %d\n"), mem);

 		console->Printf(_L("up time     : %dh:%dm:%ds\n"),

 					tothrs, totmins%60, iUpTime%60);

 		}

 	iTimer.After(iStatus, 1000000);

 	}

 //-----------------------------------------------------------------------------

 /**

     Dismounts the originally mounted FS and optional primary extension from the drive and stores 

     this information in the FS descriptor

     @return on success returns a pointer to the instantinated FS descriptor

 */

 static CFileSystemDescriptor* DoDismountOrginalFS(RFs& aFs, TInt aDrive)

     {

     TInt        nRes;

     TBuf<128>   fsName;

     TBuf<128>   primaryExtName;

     TBool       bDrvSync = EFalse;

     Log(_L("# DoDismountOrginalFS drv:%d\n"), aDrive);

     //-- 1. get file system name

     nRes = aFs.FileSystemName(fsName, aDrive);

     if(nRes != KErrNone)

         {//-- probably no file system installed at all

         return NULL;

         }

     //-- 2. find out if the drive sync/async

     TPckgBuf<TBool> drvSyncBuf;

     nRes = aFs.QueryVolumeInfoExt(aDrive, EIsDriveSync, drvSyncBuf);

     if(nRes == KErrNone)

         {

         bDrvSync = drvSyncBuf();

         }

     //-- 3. find out primary extension name if it is present; we will need to add it againt when mounting the FS

     //-- other extensions (non-primary) are not supported yet

     nRes = aFs.ExtensionName(primaryExtName, aDrive, 0);

     if(nRes != KErrNone)

         {   

         primaryExtName.SetLength(0);

         }

     //-- 3.1 check if the drive has non-primary extensions, fail in this case, because this FS can't be mounted back normally

     nRes = aFs.ExtensionName(primaryExtName, aDrive, 1);

     if(nRes == KErrNone)

         {   

         LogPrint(_L("Non-primary extensions are not supported!\n"));

         return NULL;

         }

     Log(_L("# DoDismountOrginalFS FS:%S, Prim ext:%S, synch:%d\n"), &fsName, &primaryExtName, bDrvSync);

     //-- create FS descriptor and dismount the FS

     CFileSystemDescriptor* pFsDesc = NULL; 

     TRAP(nRes, pFsDesc = CFileSystemDescriptor::NewL(fsName, primaryExtName, bDrvSync));

     if(nRes != KErrNone)

         return NULL; //-- OOM ?

     nRes = aFs.DismountFileSystem(fsName, aDrive);

     if(nRes != KErrNone)

         {

         delete pFsDesc;

         pFsDesc = NULL;

         Log(_L("# DoDismountOrginalFS Dismounting Err:%d\n"), nRes);

         }

     return pFsDesc;

 }

 //-----------------------------------------------------------------------------

 /**

     Tries to restore the original FS on the drive using the FS descriptor provided

     @return standard error code.

 */

 static TInt DoRestoreFS(RFs& aFs, TInt aDrive, CFileSystemDescriptor* apFsDesc)

     {

     TInt nRes;

     Log(_L("# DoRestoreFS drv:%d\n"), aDrive);

     //-- 1. check that there is no FS installed

         {

         TBuf<128>   fsName;

         nRes = aFs.FileSystemName(fsName, aDrive);

         if(nRes == KErrNone)

             {//-- probably no file system installed at all

             Log(_L("# This drive already has FS intalled:%S \n"), &fsName);

             return KErrAlreadyExists;

             }

         }

     TPtrC ptrN  (apFsDesc->FsName());

     TPtrC ptrExt(apFsDesc->PrimaryExtName());

     Log(_L("# Mounting FS:%S, Prim ext:%S, synch:%d\n"), &ptrN, &ptrExt, apFsDesc->DriveIsSynch());

     if(ptrExt.Length() >0)

         {//-- there is a primary extension to be mounted

         nRes = aFs.AddExtension(ptrExt);

         if(nRes != KErrNone && nRes != KErrAlreadyExists)

             {

             return nRes;

             }

         nRes = aFs.MountFileSystem(ptrN, ptrExt, aDrive, apFsDesc->DriveIsSynch());

         }

     else

         {

         nRes = aFs.MountFileSystem(ptrN, aDrive, apFsDesc->DriveIsSynch());

         }

     if(nRes != KErrNone)

         {

         Log(_L("# Mount failed! code:%d\n"),nRes);    

         }

     return nRes;

     }

 //-----------------------------------------------------------------------------

 /**

     Dismount the original FS from the drive and mount MsFS instead

 */

 static void MountMsFs(TInt driveNumber)

 	{

 	TInt x = console->WhereX();

 	TInt y = console->WhereY();

     //-- 1. try dismounting the original FS

     CFileSystemDescriptor* fsDesc = DoDismountOrginalFS(fs, driveNumber);

     unmountedFsList[driveNumber] = fsDesc;

     console->SetPos(0, 10);

     if(fsDesc)

         {

         TPtrC ptrN(fsDesc->FsName());

         LogPrint(_L("drv:%d FS:%S Dismounted OK"),driveNumber, &ptrN);

         }

     else

         {

         LogPrint(_L("drv:%d Dismount FS Failed!"),driveNumber);

         }

     console->ClearToEndOfLine();

     //-- 2. try to mount the "MSFS"

     TInt error;

     error = fs.MountFileSystem(KMsFs, driveNumber);

 	console->SetPos(0, 11);

 	LogPrint(_L("MSFS Mount:   %S (%d)"), (error?&KError:&KOk), error);

 	console->ClearToEndOfLine();

 	if (!error)

 		msfsMountedList[driveNumber] = ETrue;

 	// restore console position

 	console->SetPos(x,y);

 	}

 //-----------------------------------------------------------------------------

 /**

     Dismount MsFS and mount the original FS 

 */

 static TInt RestoreMount(TInt driveNumber)

 	{

 	TInt err = KErrNone;

 	TInt x = console->WhereX();

 	TInt y = console->WhereY();

     //-- 1. try dismounting the "MSFS"

 	if (msfsMountedList[driveNumber])

 		{

 		err = fs.DismountFileSystem(KMsFs, driveNumber);

 		console->SetPos(0, 11);

 		LogPrint(_L("MSFS Dismount:%S (%d)"), (err?&KError:&KOk), err);

 		console->ClearToEndOfLine();

 		if (err)

 			return err;

 		msfsMountedList[driveNumber] = EFalse;

         }

     //-- 2. try to mount the original FS back

     CFileSystemDescriptor* fsDesc = unmountedFsList[driveNumber];

     if(fsDesc)

         {

         err = DoRestoreFS(fs, driveNumber, fsDesc);

         TPtrC ptrN(fsDesc->FsName());

         console->SetPos(0, 10);

         LogPrint(_L("%S Mount:    %S (%d)"), &ptrN, (err?&KError:&KOk), err);

         console->ClearToEndOfLine();

         delete fsDesc;

         unmountedFsList[driveNumber] = NULL;

         }

     // restore console position

 	console->SetPos(x,y);

 	return err;

 	}

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

 //

 // CPropertyWatch

 // An active object that tracks changes to the KUsbMsDriveState properties

 //

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

 CPropertyWatch* CPropertyWatch::NewLC(TUsbMsDriveState_Subkey aSubkey, PropertyHandlers::THandler aHandler)

 	{

 	CPropertyWatch* me=new(ELeave) CPropertyWatch(aHandler);

 	CleanupStack::PushL(me);

 	me->ConstructL(aSubkey);

 	return me;

 	}

 CPropertyWatch::CPropertyWatch(PropertyHandlers::THandler aHandler)

 	: CActive(0), iHandler(aHandler)

 	{}

 void CPropertyWatch::ConstructL(TUsbMsDriveState_Subkey aSubkey)

 	{

 	User::LeaveIfError(iProperty.Attach(KUsbMsDriveState_Category, aSubkey));

 	CActiveScheduler::Add(this);

 	// initial subscription and process current property value

 	RunL();

 	}

 CPropertyWatch::~CPropertyWatch()

 	{

 	Cancel();

 	iProperty.Close();

 	}

 void CPropertyWatch::DoCancel()

 	{

 	iProperty.Cancel();

 	}

 void CPropertyWatch::RunL()

 	{

 	// resubscribe before processing new value to prevent missing updates

 	iProperty.Subscribe(iStatus);

 	SetActive();

 	iHandler(iProperty);

 	}

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

 //

 // CUsbWatch

 //

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

 CUsbWatch* CUsbWatch::NewLC(TAny* aUsb)

 	{

 	CUsbWatch* me=new(ELeave) CUsbWatch(aUsb);

 	CleanupStack::PushL(me);

 	me->ConstructL();

 	return me;

 	}

 CUsbWatch::CUsbWatch(TAny* aUsb)

 	: 

 	CActive(0), 

 	iUsb(aUsb),

 	iUsbDeviceState(EUsbDeviceStateUndefined),

 	iWasConfigured(EFalse)

 	{}

 void CUsbWatch::ConstructL()

 	{

 	CActiveScheduler::Add(this);

 	RunL();

 	}

 CUsbWatch::~CUsbWatch()

 	{

 	Cancel();

 //	iUsb.DeviceStateNotificationCancel();

 	if (gSharedChunkLdd)

 		((RDevUsbcScClient*)iUsb)->AlternateDeviceStatusNotifyCancel();

 	else

 		((RDevUsbcClient*)iUsb)->AlternateDeviceStatusNotifyCancel();

 	}

 void CUsbWatch::DoCancel()

 	{

 //	iUsb.DeviceStateNotificationCancel();

 	if (gSharedChunkLdd)

 		((RDevUsbcScClient*)iUsb)->AlternateDeviceStatusNotifyCancel();

 	else

 		((RDevUsbcClient*)iUsb)->AlternateDeviceStatusNotifyCancel();

 	}

 static TBool IsDriveConnected(TInt driveStatusIndex)

 	{

 	TInt driveStatus = PropertyHandlers::allDrivesStatus[2*driveStatusIndex+1];

 	return driveStatus >= EUsbMsDriveState_Connected ? ETrue : EFalse;

 	}

 static TChar DriveNumberToLetter(TInt driveNumber)

 	{

 	TChar driveLetter = '?';

 	fs.DriveToChar(driveNumber, driveLetter);

 	return driveLetter;

 	}

 static TBool IsDriveInMountList(TUint driveLetter)

 	{

 	TUint16 driveLetter16 = static_cast<TUint16>(driveLetter);

 	return(!mountList.Length() || KErrNotFound != mountList.Find(&driveLetter16, 1));

 	}

 void CUsbWatch::RunL()

 	{

 //	RDebug::Print(_L(">> CUsbWatch[%d] %d"), iUsbDeviceState, iWasConfigured);

 //	const TUint stateMask = 0xFF;

 //	iUsb.DeviceStateNotification(stateMask, iUsbDeviceState, iStatus);

 	if (gSharedChunkLdd)

 		((RDevUsbcScClient*)iUsb)->AlternateDeviceStatusNotify(iStatus, iUsbDeviceState);

 	else

 		((RDevUsbcClient*)iUsb)->AlternateDeviceStatusNotify(iStatus, iUsbDeviceState);

 	SetActive();

 	//RDebug::Print(_L("CUsbWatch DeviceStateNotification: iUsbDeviceState=%d"), iUsbDeviceState);

 	// If the cable is disconnected, unmount all the connected drives.

 	if(iWasConfigured && iUsbDeviceState == EUsbDeviceStateUndefined)

 		{

 		for(TInt i=0; i<PropertyHandlers::allDrivesStatus.Length()/2; i++)

 			{

 			if(IsDriveConnected(i))

 				{

 				//RDebug::Print(_L("CUsbWatch calling RestoreMount"));

 				RestoreMount(PropertyHandlers::allDrivesStatus[2*i]);

 #ifdef USB_BOOT_LOADER

 				// exit and reboot

 				CActiveScheduler::Stop();

 #endif

 				}

 			}

 		iWasConfigured = EFalse;

 		}

 	// If cable is connected, mount all drives in the auto-mount list.

 	// This is done for performance, since if this is not done here,

 	// mounting will happen later after each drive enters the 

 	// Connecting state.

 	if(iUsbDeviceState == EUsbDeviceStateConfigured)

 		{

 		for(TInt i=0; i<PropertyHandlers::allDrivesStatus.Length()/2; i++)

 			{

 			TInt driveNumber = PropertyHandlers::allDrivesStatus[2*i];

 			if(!IsDriveConnected(i) && IsDriveInMountList(DriveNumberToLetter(driveNumber)))

 				{

 				//RDebug::Print(_L("CUsbWatch calling MountMsFs"));

 				MountMsFs(driveNumber);

 				}

 			}

 		iWasConfigured = ETrue;

 		}

 	}

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

 //

 // PropertyHandlers

 //

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

 TBuf8<16> PropertyHandlers::allDrivesStatus;

 TUsbMsBytesTransferred PropertyHandlers::iKBytesRead;

 TUsbMsBytesTransferred PropertyHandlers::iKBytesWritten;

 TInt PropertyHandlers::iMediaError;

 void PropertyHandlers::Read(RProperty& aProperty)

 	{

 	Transferred(aProperty, iKBytesRead);

 	}

 void PropertyHandlers::Written(RProperty& aProperty)

 	{

 	Transferred(aProperty, iKBytesWritten);

 	}

 void PropertyHandlers::Transferred(RProperty& aProperty, TUsbMsBytesTransferred& aReadOrWritten)

 	{

 	console->SetPos(0,1);

 	console->Printf(_L("KB R/W:  "));

 	TInt err = aProperty.Get(aReadOrWritten);

 	if(err == KErrNone)

 		{

 		for(TInt i = 0; i < allDrivesStatus.Length()/2; i++)

 			{

 			console->Printf(KBytesTransferredFmt, (char)DriveNumberToLetter(allDrivesStatus[2*i]), iKBytesRead[i], iKBytesWritten[i]);

 			}

 		console->ClearToEndOfLine();

 		}

 	else

 		{

 		console->Printf(KErrFmt, err);

 		}

 	}

 void PropertyHandlers::DriveStatus(RProperty& aProperty)

 	{

 //	RDebug::Print(_L(">> PropertyHandlers::DriveStatus"));

 	TInt err = aProperty.Get(allDrivesStatus);

 	console->SetPos(0,0);

 	if(err == KErrNone)

 		{

 		LogPrint(_L("Status:  "));

 		for(TInt i = 0; i < allDrivesStatus.Length()/2; i++)

 			{

 			TInt driveNumber = allDrivesStatus[2*i];

 			TInt driveStatus = allDrivesStatus[2*i+1];

 			TChar driveLetter = DriveNumberToLetter(driveNumber);

 //			RDebug::Print(_L("%c:%d   "), (char)driveLetter, driveStatus);

 			switch(driveStatus)

 				{

 				case EUsbMsDriveState_Disconnected:

 					{

 					LogPrint(_L("%c:%d:Disconnected "), (char)driveLetter, driveStatus);

 					break;

 					}

 				case EUsbMsDriveState_Connecting:

 					{

 					LogPrint(_L("%c:%d:Connecting   "), (char)driveLetter, driveStatus);

 					break;

 					}

 				case EUsbMsDriveState_Connected:

 					{

 					LogPrint(_L("%c:%d:Connected    "), (char)driveLetter, driveStatus);

 					break;

 					}

 				case EUsbMsDriveState_Disconnecting:

 					{

 					LogPrint(_L("%c:%d:Disconnecting"), (char)driveLetter, driveStatus);

 					break;

 					}

 				case EUsbMsDriveState_Active:

 					{

 					LogPrint(_L("%c:%d:Active       "), (char)driveLetter, driveStatus);

 					break;

 					}

 				case EUsbMsDriveState_Locked:

 					{

 					LogPrint(_L("%c:%d:Locked       "), (char)driveLetter, driveStatus);

 					break;

 					}

 				case EUsbMsDriveState_MediaNotPresent:

 					{

 					LogPrint(_L("%c:%d:Not Present  "), (char)driveLetter, driveStatus);

 					break;

 					}

 				case EUsbMsDriveState_Removed:

 					{

 					LogPrint(_L("%c:%d:Removed      "), (char)driveLetter, driveStatus);

 					break;

 					}

 				case EUsbMsDriveState_Error:

 					{

 					LogPrint(_L("%c:%d:Error        "), (char)driveLetter, driveStatus);

 					break;

 					}

 				default :

 					{

 					LogPrint(_L("%c:%d:Unknown      "), (char)driveLetter, driveStatus);

 					break;

 					}

 				}

 			if(IsDriveInMountList(driveLetter))

 				{

 #ifndef USB_BOOT_LOADER

 				if (driveStatus == EUsbMsDriveState_Connecting)

 					{

 					MountMsFs(driveNumber);

 					}

 				else if (driveStatus == EUsbMsDriveState_Disconnected)

 					{

 					RestoreMount(driveNumber);

 					}

 #else

 				if (driveStatus == EUsbMsDriveState_Disconnecting)

 					{

 					RestoreMount(driveNumber);

 					}

 				else if (driveStatus == EUsbMsDriveState_Disconnected)

 					{

 					static TBool firstTime = ETrue;

 					if (!firstTime)

 						{

 						RDebug::Print(_L("Eject..."));

 						// Exit and reboot the target upon receipt of an eject

 						CActiveScheduler::Stop();

 						rebootit();

 						}

 					firstTime = EFalse;

 					}

 #endif

 				else

 					{

 					//RDebug::Print(_L("PropertyHandlers::DriveStatus: nothing to do"));

 					}

 				}

 			else

 				{

 				//RDebug::Print(_L("PropertyHandlers::DriveStatus: %c: is not in mountList\n"), driveLetter);

 				}

 			}

 		}

 	else

 		{

 		LogPrint(KErrFmt, err);

 		}

 	//RDebug::Print(_L("<< PropertyHandlers::DriveStatus"));

 	}

 void PropertyHandlers::MediaError(RProperty& aProperty)

 	{

 	TInt err = aProperty.Get(iMediaError);

 	if(err != KErrNone)

 		{

 		// RDebug::Printf("RProperty::Get returned %d", err);

 		return;

 		}

 	//RDebug::Printf("PropertyHandlers::MediaError %x", iMediaError);

 	TInt x = console->WhereX();

 	TInt y = console->WhereY();

 	Clear(27,1);

 	LogPrint(_L("Media Error %x"), iMediaError);

 	// restore console position

 	console->SetPos(x,y);

 	}

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

 //

 // CMessageKeyProcessor

 //

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

 CMessageKeyProcessor::CMessageKeyProcessor(CConsoleBase* aConsole)

 	: CActive(CActive::EPriorityUserInput), iConsole(aConsole)

 	{

 	} 

 CMessageKeyProcessor* CMessageKeyProcessor::NewLC(CConsoleBase* aConsole

 												 )

 	{

 	CMessageKeyProcessor* self=new (ELeave) CMessageKeyProcessor(aConsole);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	return self;

 	}

 CMessageKeyProcessor* CMessageKeyProcessor::NewL(CConsoleBase* aConsole

 												)

 	{

 	CMessageKeyProcessor* self = NewLC(aConsole);

 	CleanupStack::Pop();

 	return self;

 	}

 void CMessageKeyProcessor::ConstructL()

 	{

 	// Add to active scheduler

 	CActiveScheduler::Add(this);

 	RequestCharacter();

 	}

 #ifndef USB_BOOT_LOADER

 void CMessageKeyProcessor::MakePassword(TMediaPassword &aPassword)

 	{

 	//  Create password with same format as eshell and S60

 	TBuf<3> password(KDefPwd);

 	// fill aPassword with contents of password, not converting to ASCII

 	const TInt byteLen = password.Length() * 2;

 	aPassword.Copy(reinterpret_cast<const TUint8 *>(password.Ptr()), byteLen);

 	}

 #endif

 CMessageKeyProcessor::~CMessageKeyProcessor()

 	{

 	// Make sure we're cancelled

 	Cancel();

 	}

 void  CMessageKeyProcessor::DoCancel()

 	{

 	iConsole->ReadCancel();

 	}

 void  CMessageKeyProcessor::RunL()

 	{

 	  // Handle completed request

 	ProcessKeyPress(TChar(iConsole->KeyCode()));

 	}

 void CMessageKeyProcessor::RequestCharacter()

 	{

 	  // A request is issued to the CConsoleBase to accept a

 	  // character from the keyboard.

 	iConsole->Read(iStatus); 

 	SetActive();

 	}

 void CMessageKeyProcessor::ProcessKeyPress(TChar aChar)

 	{

 #ifndef USB_BOOT_LOADER

 	TInt error = KErrNone;

 #endif

 #if defined(_DEBUG)

 	static TBool tracetoggle=EFalse;

 #endif

 	switch(aChar)

 		{

 		case 'q':

 		case 'Q':

 		case EKeyEscape:

 			{

 			TInt err = KErrNone;

 			for(TInt j=0; j<KMaxDrives; j++)

 				{

 				err = RestoreMount(j);

 				if (err)

 					{

 					// Mount is busy/locked and can not be restored.

 					break;

 					}

 				}

 			if (err == KErrNone)

 				{

 #ifdef USB_BOOT_LOADER

 					gRebootDelay=0;	// Force reboot to occur immediately

 #endif				

 				CActiveScheduler::Stop();

 				return;

 				}

 			}

 			break;

 #if defined(_DEBUG)

 		case 't':

 		case 'T':

 			tracetoggle=!tracetoggle;

 			if (tracetoggle)	// 0x44008401

 				User::SetDebugMask(KHARDWARE|KDLL|KSCRATCH|KPOWER|KMEMTRACE);

 			else

 				User::SetDebugMask(0);

 			break;

 #endif

 #ifndef USB_BOOT_LOADER

 		case 'd':

 		case 'D':

 			if(++selectedDriveIndex >= PropertyHandlers::allDrivesStatus.Length()/2)

 				{

 				selectedDriveIndex = 0;

 				}

 			ShowDriveSelection();

 			break;

 		case 'm':

 		case 'M':

 			if(PropertyHandlers::allDrivesStatus.Length())

 				{

 				MountMsFs(PropertyHandlers::allDrivesStatus[selectedDriveIndex*2]);

 				}

 			break;

 		case 'u':

 		case 'U':

 			if(PropertyHandlers::allDrivesStatus.Length())

 				{

 				RestoreMount(PropertyHandlers::allDrivesStatus[selectedDriveIndex*2]);

 				}

 			break;

 		case 'l':

 			{

 			// lock unprotected drive

 			TMediaPassword password;

 			MakePassword(password);

 			_LIT(KEmpty, "");

 			TMediaPassword nul;

 			nul.Copy(KEmpty);

 			error = fs.LockDrive(PropertyHandlers::allDrivesStatus[selectedDriveIndex*2],

                                  nul, password, ETrue);

 			console->SetPos(0,9);

 			LogPrint(_L("LockDrive %S (%d)"), (error?&KError:&KOk), error);

 			break;

 			}

 			case 'L':

             {

             // lock password protected drive

             TMediaPassword password;

             MakePassword(password);

             error = fs.LockDrive(PropertyHandlers::allDrivesStatus[selectedDriveIndex*2],

                                  password, password, ETrue);

             console->SetPos(0,9);

             LogPrint(_L("LockDrive %S (%d)"), (error?&KError:&KOk), error);

             break;

             }

 		case 'n':

         case 'N':

             {

             TMediaPassword password;

             MakePassword(password);

             error = fs.UnlockDrive(PropertyHandlers::allDrivesStatus[selectedDriveIndex*2],

                                    password, ETrue);

             Clear(9);

             LogPrint(_L("UnlockDrive %S (%d)"), (error?&KError:&KOk), error);

             }

 			break;

 		case 'c':

         case 'C':

             {

             TMediaPassword password;

             MakePassword(password);

             error = fs.ClearPassword(PropertyHandlers::allDrivesStatus[selectedDriveIndex*2],

                                      password);

             Clear(9);

             LogPrint(_L("ClearPassword %S (%d)"), (error?&KError:&KOk), error);

             }

 			break;

 #endif

 		default:

 			break;

 		}

 	RequestCharacter();

 	}

 #ifdef USB_BOOT_LOADER

 static void RunMode()

 	{

 	RFs fs;

 	TInt r=fs.Connect();

 	if (r!=KErrNone)

 		{

 		RDebug::Print(_L("Help\n"));

 		return;

 		}

 	TFileName sessionpath = _L("?:\\");

 	TDriveList drivelist;

 	fs.DriveList(drivelist);

 	for (TInt driveno=EDriveC; driveno<=EDriveZ; driveno++)

 		{

 		if (!drivelist[driveno])

 			continue;

 		sessionpath[0]='A'+driveno;

 		/*

 		 If a filename with the format EJECTDELAY.nnn is found, delay any reboot

 		 action by "nnn" seconds

 		 */

 		CDir* dir;

 		TFindFile finder(fs);

 		r=finder.FindWildByPath(_L("EJECTDELAY.*"),&sessionpath,dir);

 		if (r == KErrNone)

 			{ // Found one or more files

 			TEntry entry;

 			entry=(*dir)[0];

 			TParse parser;

 			parser.Set(entry.iName, NULL, NULL);

 			TPtrC tok = parser.Ext();

 			TLex lex(tok);

 			lex.SkipAndMark(1);

 			tok.Set(lex.NextToken());

 			lex.Assign(tok);

 			r=lex.Val(gRebootDelay);

 			if (r!=KErrNone)

 				continue;

 			}

 		}

 	}

 #endif

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

 //

 // Application entry point

 //

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

 static void RunAppL()

 	{

 #ifdef USB_BOOT_LOADER

 	RunMode();

 #endif

     TInt error = KErrUnknown;

 	//RDebug::Print(_L("USBMSAPP: Creating console\n"));

 #ifdef USB_BOOT_LOADER

 	console = Console::NewL(KVariantUsbmsTitle,TSize(KConsFullScreen,KConsFullScreen));

 #else

 	console = Console::NewL(KTxtApp,TSize(KConsFullScreen,KConsFullScreen));

 #endif

 	CleanupStack::PushL(console);

 	console->SetPos(0,2);

 	console->Printf(_L("========================================"));

 	CActiveScheduler* sched = new(ELeave) CActiveScheduler;

 	CleanupStack::PushL(sched);

 	CActiveScheduler::Install(sched);

 	TBuf<20> KDriverFileName;

 	// Load the logical device

 	RDevUsbcClient usb;

 	RDevUsbcScClient usbsc;

 	RChunk gChunk;

 	fs.Connect();

 	CleanupClosePushL(fs);

 	_LIT(KMountAllDefault,"(all)");

 	console->SetPos(0,3);

 	LogPrint(_L("Drives to auto-mount: %S"), (mountList.Length() ? &mountList : &KMountAllDefault));

 	// Add MS file system

 	error = fs.AddFileSystem(KMsFsy);

 	if(error != KErrNone && error != KErrAlreadyExists)

 		{

 		User::Leave(error);

 		}

 	console->SetPos(0,4);

 	LogPrint(_L("MSFS file system:\tAdded OK\n"));

 	if (gSharedChunkLdd)

 		{

 		KDriverFileName = _L("EUSBCSC.LDD");

 		error = User::LoadLogicalDevice(KDriverFileName);

 		}

 	else

 		{

 		KDriverFileName = _L("EUSBC.LDD");

 		error = User::LoadLogicalDevice(KDriverFileName);

 		}

 	if (error != KErrAlreadyExists)

 		{

 		User::LeaveIfError(error);

 		}

 	if (gSharedChunkLdd)

 		{

 		error = usbsc.Open(0);

 		}

 	else

 		{

 		error = usb.Open(0);

 		}

 	User::LeaveIfError(error);

 #ifdef BUILD_OTG_USBMSAPP

 	_LIT(KOtgdiLddFilename, "otgdi");

 	// Check for OTG support

 	TBuf8<KUsbDescSize_Otg> otg_desc;

 		if (gSharedChunkLdd)

 		{

 		error = usbsc.GetOtgDescriptor(otg_desc);

 		}

 	else

 		{

 		error = usb.GetOtgDescriptor(otg_desc);

 		}

 	if (!(error == KErrNotSupported || error == KErrNone))

 		{

 		LogPrint(_L("Error %d while fetching OTG descriptor"), error);

 		User::Leave(-1);

 		return;

 		}

 	// On an OTG device we have to start the OTG driver, otherwise the Client

 	// stack will remain disabled forever.

 	if (error == KErrNotSupported)

 	{

 	if (gSharedChunkLdd)

 		{

 		CleanupClosePushL(usbsc);

 		}

 	else

 		{

 		CleanupClosePushL(usb);

 		}

 		User::Leave(-1);

 	}

 	error = User::LoadLogicalDevice(KOtgdiLddFilename);

 	if (error != KErrNone)

 		{

 		LogPrint(_L("Error %d on loading OTG LDD"), error);

 		User::Leave(-1);

 		return;

 		}

 	RUsbOtgDriver iOtgPort;

 	error = iOtgPort.Open();

 	if (error != KErrNone)

 		{

 		LogPrint(_L("Error %d on opening OTG port"), error);

 		User::Leave(-1);

 		return;

 		}

 	error = iOtgPort.StartStacks();

 	if (error != KErrNone)

 		{

 		LogPrint(_L("Error %d on starting USB stack"), error);

 		User::Leave(-1);

 		return;

 		}

 #endif

 	if (gSharedChunkLdd)

 		{

 		CleanupClosePushL(usbsc);

 		RChunk *tChunk = &gChunk;

 		usbsc.FinalizeInterface(tChunk);

 		}

 	else

 		{

 		CleanupClosePushL(usb);

 		}

 //		RDebug::Print(_L("USBMSAPP: Create active objects\n"));

 	CMessageKeyProcessor::NewLC(console);

 	CPropertyWatch::NewLC(EUsbMsDriveState_KBytesRead, PropertyHandlers::Read);

 	CPropertyWatch::NewLC(EUsbMsDriveState_KBytesWritten, PropertyHandlers::Written);

 	CPropertyWatch::NewLC(EUsbMsDriveState_DriveStatus, PropertyHandlers::DriveStatus);

 	CPropertyWatch::NewLC(EUsbMsDriveState_MediaError, PropertyHandlers::MediaError);

 	if (gSharedChunkLdd)

 		{

 		CUsbWatch::NewLC(&usbsc);

 		}

 	else

 		{

 		CUsbWatch::NewLC(&usb);

 		}

 	CPeriodUpdate::NewLC();

 	RUsbMassStorage UsbMs;

 	TBuf<8>  t_vendorId(_L("vendor"));

 	TBuf<16> t_productId(_L("product"));

 	TBuf<4>  t_productRev(_L("1.00"));

 	TMassStorageConfig msConfig;

 	msConfig.iVendorId.Copy(t_vendorId);

 	msConfig.iProductId.Copy(t_productId);

 	msConfig.iProductRev.Copy(t_productRev);

 //   	console->Printf(_L("Connect to Mass Storage"));

 	error = UsbMs.Connect();

 	User::LeaveIfError(error);

 //   	console->Printf(_L("Start Mass Storage"));

 	error = UsbMs.Start(msConfig);

 	User::LeaveIfError(error);

 	TBuf8<KUsbDescSize_Device> deviceDescriptor;

 	if (gSharedChunkLdd)

 		{

 		error = usbsc.GetDeviceDescriptor(deviceDescriptor);

 		}

 	else

 		{

 		error = usb.GetDeviceDescriptor(deviceDescriptor);

 		}

 	User::LeaveIfError(error);

 	const TInt KUsbSpecOffset = 2;

 	const TInt KUsbDeviceClassOffset = 4;

 	const TInt KUsbVendorIdOffset = 8;

 	const TInt KUsbProductIdOffset = 10;

 	const TInt KUsbDevReleaseOffset = 12;

 	//Change the USB spec number to 2.00

 	deviceDescriptor[KUsbSpecOffset]   = 0x00;

 	deviceDescriptor[KUsbSpecOffset+1] = 0x02;

 	//Change the Device Class, Device SubClass and Device Protocol 

 	deviceDescriptor[KUsbDeviceClassOffset] = 0x00;

 	deviceDescriptor[KUsbDeviceClassOffset+1] = 0x00;

 	deviceDescriptor[KUsbDeviceClassOffset+2] = 0x00;

 	//Change the device vendor ID (VID) to 0x0E22 (Symbian)

 	deviceDescriptor[KUsbVendorIdOffset]   = 0x22;   // little endian

 	deviceDescriptor[KUsbVendorIdOffset+1] = 0x0E;

 	//Change the device product ID (PID) to 0x1111

 	deviceDescriptor[KUsbProductIdOffset]   = 0x12;

 	deviceDescriptor[KUsbProductIdOffset+1] = 0x11;

 	//Change the device release number to 3.05

 	deviceDescriptor[KUsbDevReleaseOffset]   = 0x05;

 	deviceDescriptor[KUsbDevReleaseOffset+1] = 0x03;

 	if (gSharedChunkLdd)

 		{

 		error = usbsc.SetDeviceDescriptor(deviceDescriptor);

 		}

 	else

 		{

 		error = usb.SetDeviceDescriptor(deviceDescriptor);

 		}

 	User::LeaveIfError(error);

 	// Remove possible Remote-Wakup support in Configuration descriptor,

 	// so that we can use the MSC device also easily for Chapter9 testing.

 	TBuf8<KUsbDescSize_Config> configDescriptor;

 	if (gSharedChunkLdd)

 		{

 		error = usbsc.GetConfigurationDescriptor(configDescriptor);

 		}

 	else

 		{

 		error = usb.GetConfigurationDescriptor(configDescriptor);

 		}

 	User::LeaveIfError(error);

 	const TInt KConfDesc_AttribOffset = 7;

 	configDescriptor[KConfDesc_AttribOffset] &= ~KUsbDevAttr_RemoteWakeup;

 	if (gSharedChunkLdd)

 		{

 		error = usbsc.SetConfigurationDescriptor(configDescriptor);

 		}

 	else

 		{

 		error = usb.SetConfigurationDescriptor(configDescriptor);

 		}

 	User::LeaveIfError(error);

 	_LIT16(productID_L, "Symbian USB Mass Storage Device (Base)");

 	TBuf16<KUsbStringDescStringMaxSize / 2> productID(productID_L);

 		if (gSharedChunkLdd)

 		{

 		error = usbsc.SetProductStringDescriptor(productID);

 		}

 	else

 		{

 		error = usb.SetProductStringDescriptor(productID);

 		}

 	User::LeaveIfError(error); 

 	TRequestStatus enum_status;

 	console->SetPos(0,5);

 	LogPrint(_L("Re-enumerating...\n"));

 #ifdef BUILD_OTG_USBMSAPP

     // For OTG: The USB stack may not yet in the peripheral role. If it is not,

     // then ReEnumerate() will not work here as the stack will ignore the call

     // since the stack is not active. Therefore we simulate device connection to

     // force the stack into peripheral role by calling DeviceConnectToHost().

 	if (gSharedChunkLdd)

 		{

         usbsc.DeviceConnectToHost();

         usbsc.ReEnumerate(enum_status);

 		}

 	else

 		{

         usb.DeviceConnectToHost();

         usb.ReEnumerate(enum_status);		

 		}    

 #else

 	if (gSharedChunkLdd)

 		{

 		usbsc.ReEnumerate(enum_status);

 		}

 	else

 		{

 		usb.ReEnumerate(enum_status);

 		}

 #endif

 	User::LeaveIfError(error);

 	console->SetPos(0,5);

 	User::WaitForRequest(enum_status);

 	if(enum_status.Int() == KErrNone)

 		LogPrint(_L("Re-enumeration Done\n"));

 	else

 		LogPrint(_L("Re-enumeration not successfully done\n"));

 #ifndef USB_BOOT_LOADER

     console->SetPos(0,14);

     TBuf<3>password(KDefPwd);

     LogPrint(_L("Password: %S"), &password);

 #endif

 	ShowDriveSelection();

 	console->SetPos(0,17);

 #ifdef USB_BOOT_LOADER

 	_LIT(KMsgTitleB,"Menu:\n[Esc,Q]=RESET (boot image)\n");

 #else

 	_LIT(KMsgTitleB,"Menu: q=quit  d=chg drv\n      m=mount u=unmount\n       l=lock n=unlock\n      c=clr pwd");

 #endif

 	//RDebug::Print(_L("USBMSAPP: Start CActiveScheduler\n"));

 	console->Printf(KMsgTitleB);

 #ifdef USB_BOOT_LOADER

 	// Mount the mass storage on variant specific drive

 	MountMsFs(KVariantUsbmsRemoveableDrive);

 #endif

 	CActiveScheduler::Start();

 	error = UsbMs.Stop();

 	User::LeaveIfError(error);

 	UsbMs.Close();

 	error = fs.RemoveFileSystem(KMsFs);

 	User::LeaveIfError(error);

 	//The console object is left on the Cleanup Stack,

 	//which is used in the delay processing logic of rebootit(). 

 	CleanupStack::PopAndDestroy(10);

 #ifdef BUILD_OTG_USBMSAPP

 	iOtgPort.StopStacks();

 	iOtgPort.Close();

 	error = User::FreeLogicalDevice(RUsbOtgDriver::Name());

 	User::LeaveIfError(error);

 #endif

 	// UnLoad the logical device

 	TBuf<20> KDriverName;

 	if (gSharedChunkLdd)

 		{

 		KDriverName = _L("USBCSC");

 		gChunk.Close();

 		usbsc.Close();

 		User::After(100000);

 		error = User::FreeLogicalDevice(KDriverName);

 		}

 	else

 		{

 		KDriverName = _L("USBC");

 		error = User::FreeLogicalDevice(KDriverName);

 		}

 	User::LeaveIfError(error); 

 #ifdef USB_BOOT_LOADER

 	rebootit();

 #endif

 	CleanupStack::PopAndDestroy(1);

 	}

 TInt ParseCommandLine()

 	{

 	TBuf<32> args;

 	User::CommandLine(args);

 	TLex lex(args);

 	TInt err=KErrNone;

 	FOREVER

 		{

 		TPtrC token=lex.NextToken();

 		if(token.Length()!=0)

 			{

 			if ((token.MatchF(_L("-sc")) == KErrNone))

 				{

 				gSharedChunkLdd = ETrue;

 				err = KErrNone;

 				}

 			else

 				{

 				// Command line: list of drive letters to auto-mount (all if not specified)

 				mountList.Append(token);

 				mountList.UpperCase();

 				err = KErrNone;

 				} // endif token 

 			}

 		else

 			break;

 		}

 	return err;

 	}

 GLDEF_C TInt E32Main()

 	{

 	__UHEAP_MARK;

 	CTrapCleanup* cleanup=CTrapCleanup::New();

 	if (ParseCommandLine())

 		return KErrNone;

     msfsMountedList.Reset();  

     unmountedFsList.Reset();  

     TRAPD(error,RunAppL());

 #ifdef USB_BOOT_LOADER

 	__ASSERT_ALWAYS(!error, User::Panic(KVariantUsbmsTitle, error));

 #else

 	__ASSERT_ALWAYS(!error, User::Panic(KTxtApp, error));

 #endif

 	delete cleanup;

 	__UHEAP_MARKEND;

 	return 0;

 	}

 //-----------------------------------------------------------------------------

 CFileSystemDescriptor::~CFileSystemDescriptor()

     {

     iFsName.Close();

     iPrimaryExtName.Close();

     }

 //-----------------------------------------------------------------------------

 CFileSystemDescriptor* CFileSystemDescriptor::NewL(const TDesC& aFsName, const TDesC& aPrimaryExtName, TBool aDrvSynch)

     {

     CFileSystemDescriptor* pSelf = new (ELeave) CFileSystemDescriptor;

     CleanupStack::PushL(pSelf);

     pSelf->iFsName.CreateMaxL(aFsName.Length());

     pSelf->iFsName.Copy(aFsName);

     pSelf->iPrimaryExtName.CreateMaxL(aPrimaryExtName.Length());

     pSelf->iPrimaryExtName.Copy(aPrimaryExtName);

     pSelf->iDriveSynch = aDrvSynch;

     CleanupStack::Pop();

     return pSelf;

     }