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

 //

 /**

  @file

  @internalTechnology

 */

 #include <e32std.h>

 #include <f32file.h>

 #include "rusbhostmsdevice.h"

 #include "debug.h"

 #include "msgservice.h"

 _LIT(KFileSystem, "FAT");

 TVersion RUsbHostMsDevice::Version() const

     {

 	__FNLOG("RUsbHostMsDevice::Version");

     return(TVersion(KUsbHostMsSrvMajorVersionNumber,

                     KUsbHostMsSrvMinorVersionNumber,

                     KUsbHostMsSrvBuildVersionNumber));

     }

 TInt RUsbHostMsDevice::StartServer()

     {

 	__FNLOG("RUsbHostMsDevice::StartServer");

     TInt r;

     RProcess server;

     const TUid KServerUid3={0x10286A83};

     const TUidType serverUid(KNullUid,KNullUid,KServerUid3);

     // Create the server process

     if((r=server.Create(KUsbHostMsServerName,KNullDesC,serverUid)) != KErrNone)

         {

         __PRINT1(_L("Server process create = %d\n"), r);

         return r;

         }

     // Create the rendezvous request with the server process

     TRequestStatus stat;

     server.Rendezvous(stat);

     if (stat!=KRequestPending)

         {

         server.Kill(0);    // If the outstanding request is not pending then kill the server

         }

     else

         {

 		server.SetPriority(EPriorityHigh);

         server.Resume(); // start the server

         }

     // Test whether the process has ended and if it has ended, return how it ended.

     User::WaitForRequest(stat);

     r=(server.ExitType()==EExitPanic) ? KErrGeneral : stat.Int();

     server.Close();

     return r;

     }

 EXPORT_C RUsbHostMsDevice::RUsbHostMsDevice()

     {

         // Intentionally left blank

     }

 /**

 @internalAll

 @prototype

 Add the Mass Storage device to the MSC server. This API is asynchronous, upon

 completion one could find the number of logical units present in the added

 device by calling GetNumLun API. Calling the Remove API before completing this

 asynchronous API will complete the pending request notification with KErrCancel.

 @param aConfig [In] A constant reference object to

                 THostMassStorageConfig containing the confiquration values of

                 the massstorage device requested to add to the MSC

 @param aStatus [In] A reference to TRequestStatus to be used for asynchronous

                 request completion

 */

 EXPORT_C void RUsbHostMsDevice::Add(const THostMassStorageConfig& aConfig, TRequestStatus& aStatus)

     {

 	__FNLOG("RUsbHostMsDevice::Add");

     TInt err = KErrNone;

     err = CreateSession(KUsbHostMsServerName, Version(), 128, EIpcSession_GlobalSharable);

     // Being a transient server, the first session creation would fail with if

     // the server is not running

     if(err != KErrNone)

         {

         // Find whether the session creation failed because server was not

         // running

         if (err==KErrNotFound || err==KErrServerTerminated)

             {

             // Start the server

             err = StartServer();

             if(err == KErrNone)

                 {

                 // Try session creation again

                 err = CreateSession(KUsbHostMsServerName, Version(), 128, EIpcSession_GlobalSharable);

                 }

             }

         }

 	TRequestStatus* statusPtr = &aStatus;

     if(err == KErrNone)

         {

         // Create a session handle that can be passed via IPC to another process

         // (also being shared by other threads in the current process)

 		err = ShareProtected();

         if(err == KErrNone)

             {

             // synchronous call to register the interface

 			TPckg<THostMassStorageConfig> pckg(aConfig);

 	        err = SendReceive(EUsbHostMsRegisterInterface, TIpcArgs(&pckg));

 			if(err != KErrNone)

 				{

 		        User::RequestComplete(statusPtr, err);

 				}

 			else

 				{

 	            // Asynchronous call to initialise the interface

 				SendReceive(EUsbHostMsInitialiseInterface, TIpcArgs(NULL), aStatus);

 				}

 			}

         else

             {

             Close(); // Close the session handle

             __PRINT1(_L("Could not create a sharable session handle %d\n"), err);

             User::RequestComplete(statusPtr, err);

             }

         }

     else

         {

 		// Check whether the error is in starting the server or in creating the

         // session

         __PRINT1(_L("Creating server/session failed with %d\n"), err);

         User::RequestComplete(statusPtr, err);

         }

     }

 /**

 @internalAll

 @prototype

 Remove the Mass Storage device from the MSC server.

 */

 EXPORT_C void RUsbHostMsDevice::Remove()

     {

 	// Note: Here, at present we use only the interface token. But we still take

     // THostMassStorageConfig as parameter for future needs

 	__FNLOG("RUsbHostMsDevice::Remove");

 	_LIT(KUsbHostMsClientPanicCat, "usbhostmsclient");

 	TInt r = SendReceive(EUsbHostMsUnRegisterInterface);

 	r = SendReceive(EUsbHostMsFinalCleanup);

 	if(r != KErrNone)

 		{

 		User::Panic(KUsbHostMsClientPanicCat ,KErrCouldNotDisconnect);

 		}

     Close(); // Close the session handle

     }

 /**

 @internalAll

 @prototype

 Get the number of logical units suppoted by the device.

 @param aNumLuns [Out] Outputs the number of logical units found in the

                  added Mass Storage device. A value of 'n' represents there are

                  'n' LUNs present in the device, where "n > 0"

 @return TInt

 */

 EXPORT_C TInt RUsbHostMsDevice::GetNumLun(TUint32& aNumLuns)

     {

 	__FNLOG("RUsbHostMsDevice::GetNumLun");

     TPckg<TUint32> pckg(aNumLuns);

     return SendReceive(EUsbHostMsGetNumLun,TIpcArgs(&pckg));

     }

 EXPORT_C TInt RUsbHostMsDevice::MountLun(TUint32 aLunId, TInt aDriveNum)

 	{

 	__FNLOG("RUsbHostMsDevice::MountLun");

 	RFs TheFs;

 	TInt r = TheFs.Connect();

 	if(r == KErrNone)

 		{

 		TPckgBuf<TMassStorageUnitInfo> unitPkg;

 		unitPkg().iLunID = aLunId;

 		r = TheFs.MountProxyDrive(aDriveNum, _L("usbhostms"), &unitPkg, *this);

 		if(r >= KErrNone)

 			{

 			r = TheFs.MountFileSystem(KFileSystem, aDriveNum);

 			if(r != KErrNone && r != KErrNotReady && r != KErrCorrupt)

 				{

 				TheFs.DismountFileSystem(KFileSystem, aDriveNum);

 				TheFs.DismountProxyDrive(aDriveNum);

 				}

 			}

 		TheFs.Close();

 		}

 	return r;

 	}

 EXPORT_C TInt RUsbHostMsDevice::DismountLun(TInt aDriveNum)

 	{

 	__FNLOG("RUsbHostMsDevice::DismountLun");

 	RFs TheFs;

 	TInt r;

 	r = TheFs.Connect();

 	if(r == KErrNone)

 		{

 		r = TheFs.DismountFileSystem(KFileSystem, aDriveNum);

 		if(r != KErrNone)

 			{

 			// dismount failed - attempt a forced dismount

 			TRequestStatus stat;

 			TheFs.NotifyDismount(aDriveNum, stat, EFsDismountForceDismount);

 			User::WaitForRequest(stat);

 			r = stat.Int();

 			}

 		if(r == KErrNone)

 			{

 			r = TheFs.DismountProxyDrive(aDriveNum);

 			}

 		TheFs.Close();

 		}

 	return r;

 	}