//

#include "drivemanager.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmassstoragefilesystemTraces.h"

#endif

static const TInt KMsFsyMajorVersionNumber=1;

static const TInt KMsFsyMinorVersionNumber=0;

    {

    }

    {

    //Kill the controller thread if it exists

    delete iMassStorageController;

    delete iMediaChanged;

    RThread thread;

    TInt err = thread.Open(KMsThreadName);

    if (err == KErrNone)

        {

        thread.Kill(1); //Parameter is irrelevant

        }

    thread.Close();

    iMsDrives.Close();

    }

    {

    CMassStorageFileSystem*  self = new (ELeave) CMassStorageFileSystem();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

    {

    iMediaChanged = new(ELeave) CArrayFixFlat<TBool>(KMaxDrives);

    }

    {

    OstTraceFunctionEntry0(CMASSSTORAGEFILESYSTEM_100);

    iVersion=TVersion(KMsFsyMajorVersionNumber, KMsFsyMinorVersionNumber, KF32BuildVersionNumber);

    TInt err = SetName(&KMsFsyName);

    return err;

    }

    {

    OstTraceFunctionEntry0(CMASSSTORAGEFILESYSTEM_101);

    TInt err = KErrNone;

    if (iInstalled)

        {

        // Try connecting to the server to send a shutdown message.

        // - If the class controller has a session in use, this will return KErrInUse

        RUsbMassStorage usbMs;

        err = usbMs.Connect();

        if(err == KErrNone)

            {

            err = usbMs.Shutdown();

            usbMs.Close();

            if(err == KErrNone)

                {

                User::WaitForRequest(iThreadStat);

                err = iThreadStat.Int();

                }

            else

                {

                OstTrace1(TRACE_SMASSSTORAGE_FS, CMASSSTORAGEFILESYSTEM_102,

                          "Shutdown Error %d", err);

                }

            }

        else

            {

            OstTrace1(TRACE_SMASSSTORAGE_FS, CMASSSTORAGEFILESYSTEM_103,

                      "Connect Error %d", err);

            }

        }

    return(err);

    }

    {

    if (!iRunning)

        {

        User::Leave(KErrNotReady);

        }

    return CMassStorageMountCB::NewL(iMsDrives);

    }

    {

    OstTraceFunctionEntry0(CMASSSTORAGEFILESYSTEM_104);

    TLocalDriveCapsV2Buf caps;

    if (!IsValidLocalDriveMapping(aDriveNumber))

        {

        return;

        }

    (void)GetLocalDrive(aDriveNumber).Caps(caps);

    aInfo.iMediaAtt=caps().iMediaAtt;

    aInfo.iDriveAtt=caps().iDriveAtt;

    }

    {

    return *iMassStorageController;

    }

    {

    OstTraceFunctionEntry0(CMASSSTORAGEFILESYSTEM_105);

    iMsDrives.Reset();

    TInt driveCount = 0;

    TLocalDriveCapsV2Buf caps;

    for (TInt i = EDriveC; i < KMaxDrives; i++)

        {

        caps.FillZ();

        if (IsValidLocalDriveMapping(i))

            {

            TInt err = GetLocalDrive(i).Caps(caps);

            TInt locDrvNum = DriveNumberToLocalDriveNumber(i);

            OstTraceExt2(TRACE_SMASSSTORAGE_FS, CMASSSTORAGEFILESYSTEM_106,

                      "Caps: err=%d, att=%d", err, caps().iDriveAtt);

            TBool isRemovable = err==KErrNotReady || (caps().iDriveAtt & KDriveAttRemovable);

            OstTraceExt2(TRACE_SMASSSTORAGE_FS, CMASSSTORAGEFILESYSTEM_107,

                         "EnumerateMsDrives: Drive %c: removable %d", 'A'+i-EDriveA, isRemovable);

            if (isRemovable)

                {

                //

                // STF: Connect to the local drive here.  This gives us the media changed flag, and

                //      our own TBusLocalDrive object for use by the proxy drive and controller.

                //

                TBool& mediaChanged = (*iMediaChanged).ExtendL();

                mediaChanged = EFalse;

                TBusLocalDrive* localDrive = new(ELeave) TBusLocalDrive;

                iLocalDriveForMediaFlag.Append(*localDrive);

                TInt err=iLocalDriveForMediaFlag[driveCount].Connect(locDrvNum, mediaChanged);

                if(err == KErrNone)

                    {

                    iMsDrives.Append(i);

                    }

                driveCount++;

                }

            }

        }

    OstTrace1(TRACE_SMASSSTORAGE_FS, CMASSSTORAGEFILESYSTEM_108,

              "%d MS drives found", driveCount);

    return driveCount;

    }

    {

    return ETrue;

    }

    {

    OstTraceFunctionEntry0(CMASSSTORAGEFILESYSTEM_109);

    //Give the thread a name so we can kill it later

    User::RenameThread(KMsThreadName);

    CTrapCleanup* cleanup = CTrapCleanup::New();

    if (cleanup == NULL)

        {

        return KErrNoMemory;

        }

    TRAPD(err, InitThreadL());

    delete cleanup;

    OstTrace1(TRACE_SMASSSTORAGE_FS, CMASSSTORAGEFILESYSTEM_110,

              "error=%d", err);

    return err;

    }

    {

    OstTraceFunctionEntry0(CMASSSTORAGEFILESYSTEM_111);

    RSemaphore gSemThreadReady;

    TInt ret = gSemThreadReady.OpenGlobal(KMsFsysSemName);

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

        {

        User::Leave(ret);

        }

    // Determine which drives are available for Mass Storage.

    // (this also creates a local TBusLocalDrive for use by the drive controller)

    EnumerateMsDrivesL();

    CActiveScheduler* sched = new CActiveScheduler;

    if (sched == NULL)

        {

        gSemThreadReady.Signal();

        User::Leave(KErrNoMemory);

        }

    CleanupStack::PushL(sched);

    CActiveScheduler::Install(sched);

    iMassStorageController = new CUsbMassStorageController;

    if (iMassStorageController == NULL)

        {

        gSemThreadReady.Signal();

        User::Leave(KErrNoMemory);

        }

    OstTrace0(TRACE_SMASSSTORAGE_FS, CMASSSTORAGEFILESYSTEM_112,

              "Creating Mass Storage Controller");

    TRAPD(err, iMassStorageController->CreateL(iMsDrives));

    if (err != KErrNone)

        {

        gSemThreadReady.Signal();

        CActiveScheduler::Install(NULL);

        User::Leave(err);

        }

    CleanupStack::Pop(sched);

    iRunning = ETrue;

    gSemThreadReady.Signal();

    gSemThreadReady.Close();

    CActiveScheduler::Start();

    OstTrace0(TRACE_SMASSSTORAGE_FS, CMASSSTORAGEFILESYSTEM_113,"thread stopping...");

    delete iMassStorageController;

    iMassStorageController = NULL;

    TInt i=0;

    for (;i<iLocalDriveForMediaFlag.Count();i++)

        {

        iLocalDriveForMediaFlag[i].Disconnect();

        }

    iLocalDriveForMediaFlag.Reset();

    (*iMediaChanged).Reset();

    delete sched;

    iRunning = EFalse;

    OstTrace0(TRACE_SMASSSTORAGE_FS, CMASSSTORAGEFILESYSTEM_114,"thread stopped.");

    return KErrNone;

    }

    {

    User::Leave(KErrNotReady);

    return NULL;

    }

    {

    User::Leave(KErrNotReady);

    return NULL;

    }

    {

    User::Leave(KErrNotReady);

    return NULL;

    }

    {

    return KErrNotSupported;

    }

    {

    return KErrNotSupported;

    }

static TInt MsInitThreadFn(TAny* aPtr)

    {

    User::SetCritical(User::ESystemCritical);

    ((CMassStorageFileSystem*)aPtr)->InitThread();

    //Rename the thread so we can create a new one with the same original name later

    User::RenameThread(KMsDeadThreadName);

    return KErrNone;

    }

    {

    OstTraceFunctionEntry0(CMASSSTORAGEFILESYSTEM_115);

    RSemaphore gSemThreadReady;

    TInt err = gSemThreadReady.CreateGlobal(KMsFsysSemName, 0);

    if (err != KErrNone)

        {

        OstTrace1(TRACE_SMASSSTORAGE_FS, CMASSSTORAGEFILESYSTEM_116,

                  "Semaphore CreateGlobal Error %d", err);

        return NULL;

        }

    CFileSystem* msFsys = NULL;

    TRAP(err,  msFsys = CMassStorageFileSystem::NewL());

    if (err != KErrNone)

        {

        OstTrace1(TRACE_SMASSSTORAGE_FS, CMASSSTORAGEFILESYSTEM_117,

                  "MSFS Error %d",err);

        gSemThreadReady.Close();

        return NULL;

        }

    RThread msThread;

    OstTrace0(TRACE_SMASSSTORAGE_FS, CMASSSTORAGEFILESYSTEM_118,

              "Creating Mass Storage thread...");

    err = msThread.Create(KMsThreadName, MsInitThreadFn, KDefaultStackSize, NULL, msFsys);

    if (err != KErrNone)

        {

        OstTrace1(TRACE_SMASSSTORAGE_FS, CMASSSTORAGEFILESYSTEM_119,

                  "Thread Error %d", err);

        gSemThreadReady.Close();

        return msFsys;

        }

    ((CMassStorageFileSystem*)msFsys)->iInstalled=ETrue;

    msThread.Logon(((CMassStorageFileSystem*)msFsys)->iThreadStat);

    msThread.Resume();

    gSemThreadReady.Wait();

    gSemThreadReady.Close();

    msThread.Close();

    return msFsys;

    }