1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 /**

    17  @file

    18  @internalTechnology

    19 */

    20 

    21 #include <e32base.h>

    22 #include <e32base_private.h>

    23 

    24 #include "usbmshostpanic.h"

    25 #include "debug.h"

    26 #include "msdebug.h"

    27 

    28 #include "msctypes.h"

    29 #include "mprotocol.h"

    30 #include "mblocktransferprotocol.h"

    31 #include "tspcclientinterface.h"

    32 #include "cscsiprotocol.h"

    33 #include "cmassstoragefsm.h"

    34 

    35 

    36 /**

    37 Constructor

    38 

    39 @param aScsiProtocol A reference to CScsiProtocol

    40 */

    41 TMassStorage::TMassStorage(CScsiProtocol& aScsiProtocol)

    42 :   iScsiProtocol(aScsiProtocol)

    43     {

    44 	__MSFNLOG

    45     }

    46 

    47 

    48 /**

    49 Clear StatusCheck flag. Periodic status checking is used for removable media.

    50 */

    51 void CMassStorageFsm::ClearStatusCheck()

    52 {

    53 	__MSFNLOG

    54 	iStatusCheck = EFalse;

    55 }

    56 

    57 

    58 /**

    59 Set StatusCheck flag. Periodic status checking is used for removable media.

    60 */

    61 void CMassStorageFsm::SetStatusCheck()

    62 {

    63 	__MSFNLOG

    64 	iStatusCheck = ETrue;

    65 }

    66 

    67 

    68 /**

    69 Get the boolean state of StatusCheck flag.

    70 

    71 @return TBool ETrue if StatusCheck flag is set

    72 */

    73 TBool CMassStorageFsm::IsStatusCheck() const

    74 {

    75 	__MSFNSLOG

    76 	return iStatusCheck;

    77 }

    78 

    79 

    80 /**

    81 Device supports SCSI BLOCK COMMANDS.

    82 

    83 @return TBool Returns ETrue if the SBC interface is initialised

    84 */

    85 TBool TMassStorage::IsSbcSet() const

    86     {

    87 	__MSFNSLOG

    88     return iScsiProtocol.MsIsSbcSet();

    89     }

    90 

    91 /**

    92 Device is removable media

    93 

    94 @return TBool Returns ETrue if removable

    95 */

    96 TBool TMassStorage::IsRemovableMedia() const

    97     {

    98 	__MSFNSLOG

    99     return iScsiProtocol.MsIsRemovableMedia();

   100     }

   101 

   102 /**

   103 Retrieve the sense info returned by a call to SenseL

   104 

   105 @return const TSenseInfo& Returns the SCSI SENSE info

   106 */

   107 const TSenseInfo& TMassStorage::MsSenseInfo() const

   108     {

   109 	__MSFNSLOG

   110     return iScsiProtocol.MsSenseInfo();

   111     }

   112 

   113 

   114 /** SCSI Request */

   115 TMassStorage::TEvent TMassStorage::InquiryL()

   116     {

   117 	__MSFNLOG

   118     TEvent event = EEvCommandFailed;

   119 

   120     switch (iScsiProtocol.MsInquiryL())

   121         {

   122     case KErrNone:

   123         event = EEvCommandPassed;

   124         break;

   125     case KErrCommandFailed:

   126         event = EEvCommandFailed;

   127         break;

   128     case KErrNotSupported:

   129         __SCSIPRINT(_L("INQUIRY Command returned NOT SUPPORTED"));

   130         User::Leave(KErrNotSupported);

   131         break;

   132     default:

   133         User::Leave(KErrUnknown);

   134         break;

   135         }

   136     return event;

   137     }

   138 

   139 

   140 /** SCSI Request */

   141 TMassStorage::TEvent TMassStorage::SenseL()

   142     {

   143 	__MSFNLOG

   144     TEvent event = EEvCommandPassed;

   145     switch (iScsiProtocol.MsRequestSenseL())

   146         {

   147     case KErrNone:

   148         break;

   149     case KErrCommandFailed:

   150         __SCSIPRINT(_L("REQUEST SENSE Command Failed"));

   151         User::Leave(KErrNotSupported);

   152         break;

   153     default:

   154         User::Leave(KErrUnknown);

   155         break;

   156         }

   157     return event;

   158     }

   159 

   160 

   161 /** SCSI Request */

   162 TMassStorage::TEvent TMassStorage::TestUnitReadyL()

   163     {

   164 	__MSFNLOG

   165     // KErrCommandFailed indictates that device is NOT READY

   166     TInt err = iScsiProtocol.MsTestUnitReadyL();

   167     return (err == KErrNone) ? EEvCommandPassed : EEvCommandFailed;

   168     }

   169 

   170 

   171 /** SCSI Request */

   172 TMassStorage::TEvent TMassStorage::StartStopUnitL(TBool aStart)

   173     {

   174 	__MSFNLOG

   175     TInt err = iScsiProtocol.MsStartStopUnitL(aStart);

   176     return (err == KErrNone) ? EEvCommandPassed : EEvCommandFailed;

   177     }

   178 

   179 

   180 /** SCSI Request */

   181 TMassStorage::TEvent TMassStorage::PreventAllowMediumRemovalL(TBool aPrevent)

   182     {

   183 	__MSFNLOG

   184     // KErrCommandFailed indictates that device is NOT READY

   185     TInt err = iScsiProtocol.MsPreventAllowMediaRemovalL(aPrevent);

   186     return (err == KErrNone) ? EEvCommandPassed : EEvCommandFailed;

   187     }

   188 

   189 

   190 /** SCSI Request */

   191 TMassStorage::TEvent TMassStorage::ReadCapacityL()

   192     {

   193 	__MSFNLOG

   194     TInt err = iScsiProtocol.MsReadCapacityL();

   195     return ErrToEvent(err);

   196     }

   197 

   198 

   199 /** SCSI Request */

   200 TMassStorage::TEvent TMassStorage::ModeSense10L()

   201     {

   202 	__MSFNLOG

   203     TInt err = iScsiProtocol.MsModeSense10L();

   204     return ErrToEvent(err);

   205     }

   206 

   207 

   208 /** SCSI Request */

   209 TMassStorage::TEvent TMassStorage::ModeSense6L()

   210     {

   211 	__MSFNLOG

   212     TInt err = iScsiProtocol.MsModeSense6L();

   213     return ErrToEvent(err);

   214     }

   215 

   216 

   217 /**

   218 Creates and returns a pointer to CMassStorageFsm.

   219 

   220 @param aScsiProtocol A reference to the protocol providing the interface to the

   221 mass storage device.

   222 

   223 @return CMassStorageFsm* A pointer to the newly created object

   224 */

   225 CMassStorageFsm* CMassStorageFsm::NewL(CScsiProtocol& aScsiProtocol)

   226 {

   227 	__MSFNSLOG

   228 	CMassStorageFsm* r = new (ELeave) CMassStorageFsm(aScsiProtocol);

   229 

   230 	CleanupStack::PushL(r);

   231 	r->ConstructL();

   232 	CleanupStack::Pop();

   233 	return r;

   234 }

   235 

   236 void CMassStorageFsm::ConstructL()

   237     {

   238 	__MSFNLOG

   239     TInt i = 0;

   240     // EInquiryState,

   241     iStateTable[i++] = new (ELeave) TInquiryState;

   242     // EInquirySenseState,

   243     iStateTable[i++] = new (ELeave) TInquirySenseState;

   244     // ENotReadyState,

   245     iStateTable[i++] = new (ELeave) TNotReadyState;

   246     // ENotReadySenseState,

   247     iStateTable[i++] = new (ELeave) TNotReadySenseState;

   248     // EStartUnitState

   249     iStateTable[i++] = new (ELeave) TStartUnitState;

   250     //EStartUnitSenseState,

   251     iStateTable[i++] = new (ELeave) TStartUnitSenseState;

   252     //EPreventAllowMediumRemovalState,

   253     iStateTable[i++] = new (ELeave) TPreventMediumRemovalState;

   254     //EPreventAllowMediumRemovalSenseState,

   255     iStateTable[i++] = new (ELeave) TPreventMediumRemovalSenseState;

   256     //EReadCapacity10State,

   257     iStateTable[i++] = new (ELeave) TReadCapacity10State;

   258     //EModeSense10State,

   259     iStateTable[i++] = new (ELeave) TModeSense10State;

   260     //EModeSense10SenseState,

   261     iStateTable[i++] = new (ELeave) TModeSense10SenseState;

   262     //EModeSense6State,

   263     iStateTable[i++] = new (ELeave) TModeSense6State;

   264     //EModeSense6SenseState,

   265     iStateTable[i++] = new (ELeave) TModeSense6SenseState;

   266     //EConnectedState,

   267     iStateTable[i++] = new (ELeave) TConnectedState;

   268     //EStatusCheck

   269     iStateTable[i++] = new (ELeave) TStatusCheckState;

   270     //EAllowMediumRemovalState,

   271     iStateTable[i++] = new (ELeave) TAllowMediumRemovalState;

   272     //EStopUnitState,

   273     iStateTable[i++] = new (ELeave) TStopUnitState;

   274     //ESenseState,

   275     iStateTable[i++] = new (ELeave) TSenseState;

   276 

   277 #ifdef __DEBUG

   278     // verify state table

   279     for (TInt i = 0; i < iStateTable.Count(), i++)

   280         {

   281         __ASSERT_DEBUG(i == iStateTable[i].iStateId, User::Invariant());

   282         }

   283 #endif

   284 

   285     SetState(TMassStorageState::EInquiryState);

   286     }

   287 

   288 

   289 CMassStorageFsm::CMassStorageFsm(CScsiProtocol& aScsiProtocol)

   290 :   TMassStorage(aScsiProtocol),

   291     iStartStopUnitRequired(EFalse)

   292     {

   293 	__MSFNLOG

   294     }

   295 

   296 CMassStorageFsm::~CMassStorageFsm()

   297     {

   298 	__MSFNLOG

   299 

   300     for (TInt i = 0; i < iStateTable.Count(); i++)

   301         {

   302         delete iStateTable[i];

   303         }

   304     }

   305 

   306 

   307 TMassStorage::TEvent CMassStorageFsm::EntryL()

   308     {

   309 	__MSFNLOG

   310 

   311     return iState->EntryL(*this);

   312     }

   313 

   314 

   315 /**

   316 Run FSM to connect device.

   317 

   318 @return TInt KErrCompletion if successful otherwise KErrNotSupported

   319 */

   320 TInt CMassStorageFsm::ConnectLogicalUnitL()

   321     {

   322 	__MSFNLOG

   323     TInt err = KErrNone;

   324     for (;;)

   325          {

   326          err = ProcessStateL();

   327          if (err)

   328              break;

   329          }

   330     return err;

   331     }

   332 

   333 

   334 /**

   335 Run FSM to disconnect the device.

   336 

   337 @return TInt KErrCompletion if successful otherwise KErrNotSupported

   338 */

   339 TInt CMassStorageFsm::DisconnectLogicalUnitL()

   340     {

   341 	__MSFNLOG

   342     TInt err = KErrNone;

   343     for (;;)

   344          {

   345          TInt err = ProcessStateL();

   346          if (err)

   347              break;

   348          }

   349     return err;

   350     }

   351 

   352 

   353 /**

   354 Return current FSM state.

   355 

   356 @return TBool ETrue if FSM state is Connected State

   357 */

   358 TBool CMassStorageFsm::IsConnected() const

   359     {

   360 	__MSFNSLOG

   361     return iState->iStateId == TMassStorageState::EConnectedState ? ETrue : EFalse;

   362     }

   363 

   364 

   365 TInt CMassStorageFsm::ProcessStateL()

   366     {

   367 	__MSFNLOG

   368     TMassStorage::TEvent event = TMassStorage::EEvCommandFailed;

   369     TRAPD(err,  event = EntryL());

   370     if (err == KErrNotSupported)

   371         {

   372         return KErrNotSupported;

   373         }

   374     User::LeaveIfError(err);

   375 

   376     __HOSTPRINT1(_L("FSM event=%d"), event);

   377     switch (event)

   378         {

   379     case TMassStorage::EEvCommandPassed:

   380         err = ScsiCommandPassed();

   381         break;

   382     case TMassStorage::EEvCommandFailed:

   383         err = ScsiCommandFailed();

   384         break;

   385     case TMassStorage::EEvCommandError:

   386         err = ScsiCommandError();

   387         break;

   388     default:

   389         User::Panic(KUsbMsHostPanicCat, EMsFsmEvent);

   390         break;

   391         }

   392 

   393     __HOSTPRINT1(_L("FSM ProcessState completed=%d"), err);

   394     return err;

   395     }

   396 

   397 

   398 TInt CMassStorageFsm::ScsiCommandPassed()

   399     {

   400 	__MSFNLOG

   401     return iState->ScsiCommandPassed(*this);

   402     }

   403 

   404 

   405 TInt CMassStorageFsm::ScsiCommandFailed()

   406     {

   407 	__MSFNLOG

   408     return iState->ScsiCommandFailed(*this);

   409     }

   410 

   411 

   412 TInt CMassStorageFsm::ScsiCommandError()

   413     {

   414 	__MSFNLOG

   415     return iState->ScsiCommandError(*this);

   416     }

   417 

   418 

   419 /**

   420 Constructor

   421 

   422 @param aStateId The state id of the state implementation

   423 */

   424 TMassStorageState::TMassStorageState(TStateId aStateId)

   425 :   iStateId(aStateId)

   426     {

   427 	__MSFNLOG

   428     }

   429 

   430 

   431 /** 

   432    Default state does nothing. Used by states where the stalled event is not 

   433    applicable 

   434    

   435    @param aFsm

   436    

   437    @return TInt

   438  */

   439 TInt TMassStorageState::ScsiCommandError(CMassStorageFsm& /* aFsm */)

   440     {

   441     return KErrNone;

   442     }

   443 

   444 

   445 TInt TMassStorageState::SenseError(CMassStorageFsm& aFsm)

   446     {

   447 	__MSFNLOG

   448     TInt ret = KErrNone;

   449     const TSenseInfo& senseInfo = aFsm.MsSenseInfo();

   450 

   451     if (senseInfo.iSenseCode == TSenseInfo::EUnitAttention)

   452         {

   453         aFsm.SetState(TMassStorageState::EInquiryState);

   454         }

   455     else

   456         {

   457         aFsm.SetState(TMassStorageState::ENotReadyState);

   458         ret = KErrCompletion;

   459         }

   460     return ret;

   461     }

   462 

   463 

   464 /**

   465 

   466 */

   467 TInquiryState::TInquiryState()

   468 :   TMassStorageState(EInquiryState)

   469     {

   470 	__MSFNLOG

   471     }

   472 

   473 

   474 TMassStorage::TEvent TInquiryState::EntryL(CMassStorageFsm& aFsm)

   475     {

   476 	__MSFNLOG

   477     return aFsm.InquiryL();

   478     };

   479 

   480 

   481 TInt TInquiryState::ScsiCommandPassed(CMassStorageFsm& aFsm)

   482     {

   483 	__MSFNLOG

   484     aFsm.SetState(ENotReadyState);

   485     return KErrNone;

   486     };

   487 

   488 

   489 TInt TInquiryState::ScsiCommandFailed(CMassStorageFsm& aFsm)

   490     {

   491 	__MSFNLOG

   492     aFsm.SetState(EInquirySenseState);

   493     return KErrNone;

   494     }

   495 

   496 

   497 /**

   498 

   499 */

   500 TInquirySenseState::TInquirySenseState()

   501 :   TMassStorageState(EInquirySenseState)

   502     {

   503 	__MSFNLOG

   504     }

   505 

   506 

   507 TMassStorage::TEvent TInquirySenseState::EntryL(CMassStorageFsm& aFsm)

   508     {

   509 	__MSFNLOG

   510     return aFsm.SenseL();

   511     };

   512 

   513 

   514 TInt TInquirySenseState::ScsiCommandPassed(CMassStorageFsm& aFsm)

   515     {

   516 	__MSFNLOG

   517     // SENSE ERROR

   518     aFsm.SetState(TMassStorageState::EInquiryState);

   519     return KErrCompletion;

   520     };

   521 

   522 

   523 TInt TInquirySenseState::ScsiCommandFailed(CMassStorageFsm& aFsm)

   524     {

   525 	__MSFNLOG

   526     aFsm.SetState(TMassStorageState::EInquiryState);

   527     return KErrCompletion;

   528     }

   529 

   530 

   531 /**

   532 

   533 */

   534 TNotReadyState::TNotReadyState()

   535 :   TMassStorageState(ENotReadyState)

   536     {

   537 	__MSFNLOG

   538     }

   539 

   540 

   541 TMassStorage::TEvent TNotReadyState::EntryL(CMassStorageFsm& aFsm)

   542     {

   543 	__MSFNLOG

   544     return aFsm.TestUnitReadyL();

   545     }

   546 

   547 

   548 TInt TNotReadyState::ScsiCommandPassed(CMassStorageFsm& aFsm)

   549     {

   550 	__MSFNLOG

   551     if (aFsm.IsSbcSet())

   552         {

   553         if (aFsm.IsRemovableMedia())

   554             aFsm.SetState(TMassStorageState::EPreventRemovalState);

   555         else

   556             aFsm.SetState(TMassStorageState::EReadCapacityState);

   557         }

   558     else

   559         aFsm.SetState(TMassStorageState::EInquiryState);

   560     return KErrNone;

   561     }

   562 

   563 

   564 TInt TNotReadyState::ScsiCommandFailed(CMassStorageFsm& aFsm)

   565     {

   566 	__MSFNLOG

   567     aFsm.SetState(TMassStorageState::ENotReadySenseState);

   568     return KErrNone;

   569     }

   570 

   571 

   572 /**

   573 

   574 */

   575 TNotReadySenseState::TNotReadySenseState()

   576 :   TMassStorageState(ENotReadySenseState)

   577     {

   578 	__MSFNLOG

   579     }

   580 

   581 

   582 TMassStorage::TEvent TNotReadySenseState::EntryL(CMassStorageFsm& aFsm)

   583     {

   584 	__MSFNLOG

   585     return aFsm.SenseL();

   586     }

   587 

   588 

   589 TInt TNotReadySenseState::ScsiCommandPassed(CMassStorageFsm& aFsm)

   590     {

   591 	__MSFNLOG

   592     const TSenseInfo& senseInfo = aFsm.MsSenseInfo();

   593     TInt ret = KErrNone;

   594 

   595     if (senseInfo.iSenseCode == TSenseInfo::ENotReady &&

   596         senseInfo.iAdditional == TSenseInfo::EAscLogicalUnitNotReady &&

   597         senseInfo.iQualifier == TSenseInfo::EAscqInitializingCommandRequired)

   598         {

   599         aFsm.SetStartStopUnitRequired(ETrue);

   600         aFsm.SetState(TMassStorageState::EStartUnitState);

   601         }

   602     else

   603         {

   604         ret = TMassStorageState::SenseError(aFsm);

   605         }

   606 

   607     return ret;

   608     }

   609 

   610 

   611 TInt TNotReadySenseState::ScsiCommandFailed(CMassStorageFsm& aFsm)

   612     {

   613 	__MSFNLOG

   614     return TMassStorageState::SenseError(aFsm);

   615     }

   616 

   617 

   618 /**

   619 

   620 */

   621 TStartUnitState::TStartUnitState()

   622 :   TMassStorageState(EPreventRemovalState)

   623     {

   624 	__MSFNLOG

   625     }

   626 

   627 

   628 TMassStorage::TEvent TStartUnitState::EntryL(CMassStorageFsm& aFsm)

   629     {

   630 	__MSFNLOG

   631     return aFsm.StartStopUnitL(ETrue);

   632     }

   633 

   634 

   635 TInt TStartUnitState::ScsiCommandPassed(CMassStorageFsm& aFsm)

   636     {

   637 	__MSFNLOG

   638     if (aFsm.IsRemovableMedia())

   639         aFsm.SetState(TMassStorageState::EPreventRemovalState);

   640     else

   641         aFsm.SetState(TMassStorageState::EReadCapacityState);

   642     return KErrNone;

   643     }

   644 

   645 

   646 TInt TStartUnitState::ScsiCommandFailed(CMassStorageFsm& aFsm)

   647     {

   648 	__MSFNLOG

   649     aFsm.SetState(TMassStorageState::EPreventRemovalSenseState);

   650     return KErrNone;

   651     }

   652 

   653 /**

   654 

   655 */

   656 TStartUnitSenseState::TStartUnitSenseState()

   657 :   TMassStorageState(EPreventRemovalSenseState)

   658     {

   659 	__MSFNLOG

   660     }

   661 

   662 

   663 TMassStorage::TEvent TStartUnitSenseState::EntryL(CMassStorageFsm& aFsm)

   664     {

   665 	__MSFNLOG

   666     return aFsm.SenseL();

   667     }

   668 

   669 

   670 TInt TStartUnitSenseState::ScsiCommandPassed(CMassStorageFsm& aFsm)

   671     {

   672 	__MSFNLOG

   673     if (aFsm.IsRemovableMedia())

   674         aFsm.SetState(TMassStorageState::EPreventRemovalState);

   675     else

   676         aFsm.SetState(TMassStorageState::EReadCapacityState);

   677 

   678     return KErrNone;

   679     }

   680 

   681 

   682 TInt TStartUnitSenseState::ScsiCommandFailed(CMassStorageFsm& aFsm)

   683     {

   684 	__MSFNLOG

   685     TInt ret = KErrCompletion;

   686     const TSenseInfo& senseInfo = aFsm.MsSenseInfo();

   687 

   688     aFsm.SetState(TMassStorageState::EInquiryState);

   689     if (senseInfo.iSenseCode == TSenseInfo::EIllegalRequest)

   690         {

   691         aFsm.SetState(TMassStorageState::EReadCapacityState);

   692         ret = KErrNone;

   693         }

   694     else

   695         {

   696         ret = TMassStorageState::SenseError(aFsm);

   697         }

   698 

   699     return ret;

   700     }

   701 

   702 

   703 /**

   704 

   705 */

   706 TPreventMediumRemovalState::TPreventMediumRemovalState()

   707 :   TMassStorageState(EPreventRemovalState)

   708     {

   709 	__MSFNLOG

   710     }

   711 

   712 

   713 TMassStorage::TEvent TPreventMediumRemovalState::EntryL(CMassStorageFsm& aFsm)

   714     {

   715 	__MSFNLOG

   716     return aFsm.PreventAllowMediumRemovalL(ETrue);

   717     }

   718 

   719 

   720 TInt TPreventMediumRemovalState::ScsiCommandPassed(CMassStorageFsm& aFsm)

   721     {

   722 	__MSFNLOG

   723     aFsm.SetState(TMassStorageState::EReadCapacityState);

   724     return KErrNone;

   725     }

   726 

   727 

   728 TInt TPreventMediumRemovalState::ScsiCommandFailed(CMassStorageFsm& aFsm)

   729     {

   730 	__MSFNLOG

   731     aFsm.SetState(TMassStorageState::EPreventRemovalSenseState);

   732     return KErrNone;

   733     }

   734 

   735 /**

   736 

   737 */

   738 TPreventMediumRemovalSenseState::TPreventMediumRemovalSenseState()

   739 :   TMassStorageState(EPreventRemovalSenseState)

   740     {

   741 	__MSFNLOG

   742     }

   743 

   744 

   745 TMassStorage::TEvent TPreventMediumRemovalSenseState::EntryL(CMassStorageFsm& aFsm)

   746     {

   747 	__MSFNLOG

   748     return aFsm.SenseL();

   749     }

   750 

   751 

   752 TInt TPreventMediumRemovalSenseState::ScsiCommandPassed(CMassStorageFsm& aFsm)

   753     {

   754 	__MSFNLOG

   755     aFsm.SetState(TMassStorageState::EReadCapacityState);

   756     return KErrNone;

   757     }

   758 

   759 

   760 

   761 

   762 TInt TPreventMediumRemovalSenseState::ScsiCommandFailed(CMassStorageFsm& aFsm)

   763     {

   764 	__MSFNLOG

   765     TInt ret = KErrCompletion;

   766     const TSenseInfo& senseInfo = aFsm.MsSenseInfo();

   767 

   768     if (senseInfo.iSenseCode == TSenseInfo::EIllegalRequest)

   769         {

   770         aFsm.SetState(TMassStorageState::EReadCapacityState);

   771         ret = KErrNone;

   772         }

   773     else

   774         {

   775         ret = TMassStorageState::SenseError(aFsm);

   776         }

   777     return ret;

   778     }

   779 

   780 

   781 /**

   782 

   783 */

   784 TReadCapacity10State::TReadCapacity10State()

   785 :   TMassStorageState(EReadCapacityState)

   786     {

   787 	__MSFNLOG

   788     }

   789 

   790 

   791 TMassStorage::TEvent TReadCapacity10State::EntryL(CMassStorageFsm& aFsm)

   792     {

   793 	__MSFNLOG

   794     return aFsm.ReadCapacityL();

   795     };

   796 

   797 

   798 TInt TReadCapacity10State::ScsiCommandPassed(CMassStorageFsm& aFsm)

   799     {

   800 	__MSFNLOG

   801     aFsm.SetState(EModeSense10State);

   802     return KErrNone;

   803     };

   804 

   805 

   806 TInt TReadCapacity10State::ScsiCommandFailed(CMassStorageFsm& aFsm)

   807     {

   808 	__MSFNLOG

   809     aFsm.SetState(TMassStorageState::ESenseState);

   810     return KErrCompletion;

   811     }

   812 

   813 

   814 TInt TReadCapacity10State::ScsiCommandError(CMassStorageFsm& aFsm)

   815     {

   816 	__MSFNLOG

   817     aFsm.SetState(TMassStorageState::ENotReadyState);

   818     return KErrCompletion;

   819     }

   820 

   821 

   822 /**

   823 

   824 */

   825 TModeSense10State::TModeSense10State()

   826 :   TMassStorageState(EModeSense10State)

   827     {

   828 	__MSFNLOG

   829     }

   830 

   831 

   832 TMassStorage::TEvent TModeSense10State::EntryL(CMassStorageFsm& aFsm)

   833     {

   834 	__MSFNLOG

   835     return aFsm.ModeSense10L();

   836     };

   837 

   838 

   839 TInt TModeSense10State::ScsiCommandPassed(CMassStorageFsm& aFsm)

   840     {

   841 	__MSFNLOG

   842     aFsm.SetState(EConnectedState);

   843     return KErrCompletion;

   844     };

   845 

   846 

   847 TInt TModeSense10State::ScsiCommandFailed(CMassStorageFsm& aFsm)

   848     {

   849 	__MSFNLOG

   850     aFsm.SetState(EModeSense10SenseState);

   851     return KErrNone;

   852     }

   853 

   854 

   855 TInt TModeSense10State::ScsiCommandError(CMassStorageFsm& aFsm)

   856     {

   857 	__MSFNLOG

   858     aFsm.SetState(EModeSense6State);

   859     return KErrNone;

   860     }

   861 

   862 /**

   863 

   864 */

   865 TModeSense10SenseState::TModeSense10SenseState()

   866 :   TMassStorageState(EModeSense10SenseState)

   867     {

   868 	__MSFNLOG

   869     }

   870 

   871 

   872 TMassStorage::TEvent TModeSense10SenseState::EntryL(CMassStorageFsm& aFsm)

   873     {

   874 	__MSFNLOG

   875     return aFsm.SenseL();

   876     };

   877 

   878 

   879 TInt TModeSense10SenseState::ScsiCommandPassed(CMassStorageFsm& aFsm)

   880     {

   881 	__MSFNLOG

   882     TInt ret = KErrCompletion;

   883     const TSenseInfo& senseInfo = aFsm.MsSenseInfo();

   884 

   885     aFsm.SetState(TMassStorageState::EInquiryState);

   886     if (senseInfo.iSenseCode == TSenseInfo::EIllegalRequest)

   887         {

   888         aFsm.SetState(TMassStorageState::EModeSense6State);

   889         ret = KErrNone;

   890         }

   891     else

   892         {

   893         ret = TMassStorageState::SenseError(aFsm);

   894         }

   895     return ret;

   896     };

   897 

   898 

   899 TInt TModeSense10SenseState::ScsiCommandFailed(CMassStorageFsm& aFsm)

   900     {

   901 	__MSFNLOG

   902     aFsm.SetState(EInquirySenseState);

   903     return KErrCompletion;

   904     }

   905 

   906 /**

   907 

   908 */

   909 TModeSense6State::TModeSense6State()

   910 :   TMassStorageState(EModeSense6State)

   911     {

   912 	__MSFNLOG

   913     }

   914 

   915 

   916 TMassStorage::TEvent TModeSense6State::EntryL(CMassStorageFsm& aFsm)

   917     {

   918 	__MSFNLOG

   919     return aFsm.ModeSense6L();

   920     };

   921 

   922 

   923 TInt TModeSense6State::ScsiCommandPassed(CMassStorageFsm& aFsm)

   924     {

   925 	__MSFNLOG

   926     aFsm.SetState(EConnectedState);

   927     return KErrCompletion;

   928     };

   929 

   930 

   931 TInt TModeSense6State::ScsiCommandFailed(CMassStorageFsm& aFsm)

   932     {

   933 	__MSFNLOG

   934     aFsm.SetState(EModeSense6SenseState);

   935     return KErrNone;

   936     }

   937 

   938 

   939 TInt TModeSense6State::ScsiCommandError(CMassStorageFsm& aFsm)

   940     {

   941 	__MSFNLOG

   942     // If device responds with protocol error, ignore the error and assume the

   943     // device is not write protected

   944     aFsm.SetState(EConnectedState);

   945     return KErrCompletion;

   946     }

   947 

   948 

   949 /**

   950 

   951 */

   952 TModeSense6SenseState::TModeSense6SenseState()

   953 :   TMassStorageState(EModeSense6SenseState)

   954     {

   955 	__MSFNLOG

   956     }

   957 

   958 

   959 TMassStorage::TEvent TModeSense6SenseState::EntryL(CMassStorageFsm& aFsm)

   960     {

   961 	__MSFNLOG

   962     return aFsm.SenseL();

   963     };

   964 

   965 

   966 TInt TModeSense6SenseState::ScsiCommandPassed(CMassStorageFsm& aFsm)

   967     {

   968 	__MSFNLOG

   969     TInt ret = KErrCompletion;

   970     const TSenseInfo& senseInfo = aFsm.MsSenseInfo();

   971 

   972     aFsm.SetState(TMassStorageState::EInquiryState);

   973     if (senseInfo.iSenseCode == TSenseInfo::EIllegalRequest)

   974         {

   975         aFsm.SetState(TMassStorageState::EConnectedState);

   976         }

   977     else

   978         {

   979         ret = TMassStorageState::SenseError(aFsm);

   980         }

   981     return ret;

   982     };

   983 

   984 

   985 TInt TModeSense6SenseState::ScsiCommandFailed(CMassStorageFsm& aFsm)

   986     {

   987 	__MSFNLOG

   988     aFsm.SetState(EInquirySenseState);

   989     return KErrCompletion;

   990     }

   991 

   992 

   993 

   994 /**

   995 

   996 */

   997 TConnectedState::TConnectedState()

   998 :   TMassStorageState(EConnectedState)

   999     {

  1000 	__MSFNLOG

  1001     }

  1002 

  1003 

  1004 TMassStorage::TEvent TConnectedState::EntryL(CMassStorageFsm& /* aFsm */)

  1005     {

  1006 	__MSFNLOG

  1007     return TMassStorage::EEvCommandPassed;

  1008     };

  1009 

  1010 

  1011 TInt TConnectedState::ScsiCommandPassed(CMassStorageFsm& aFsm)

  1012     {

  1013 	__MSFNLOG

  1014     TInt ret = KErrNone;

  1015 

  1016     if (aFsm.IsRemovableMedia())

  1017         {

  1018 		if(aFsm.IsStatusCheck())

  1019 			{

  1020 			aFsm.SetState(TMassStorageState::EStatusCheckState);

  1021 			}

  1022 		else

  1023             {

  1024             aFsm.SetState(TMassStorageState::EAllowRemovalState);

  1025             }

  1026         }

  1027     else if (aFsm.StartStopUnitRequired())

  1028         {

  1029         aFsm.SetState(TMassStorageState::EStopUnitState);

  1030         }

  1031     else

  1032         {

  1033 		aFsm.SetState(TMassStorageState::ENotReadyState);

  1034 		ret = KErrCompletion;

  1035         }

  1036     return ret;

  1037     };

  1038 

  1039 

  1040 TInt TConnectedState::ScsiCommandFailed(CMassStorageFsm& aFsm)

  1041     {

  1042 	__MSFNLOG

  1043     aFsm.SetState(TMassStorageState::EInquiryState);

  1044     return KErrCompletion;

  1045     }

  1046 

  1047 

  1048 /**

  1049 

  1050 */

  1051 TStatusCheckState::TStatusCheckState()

  1052 :   TMassStorageState(EStatusCheckState)

  1053     {

  1054 	__MSFNLOG

  1055     }

  1056 

  1057 

  1058 TMassStorage::TEvent TStatusCheckState::EntryL(CMassStorageFsm& aFsm)

  1059     {

  1060 	__MSFNLOG

  1061     return aFsm.TestUnitReadyL();

  1062     };

  1063 

  1064 

  1065 TInt TStatusCheckState::ScsiCommandPassed(CMassStorageFsm& aFsm)

  1066     {

  1067 	__MSFNLOG

  1068     aFsm.SetState(EConnectedState);

  1069     return KErrCompletion;

  1070     };

  1071 

  1072 

  1073 TInt TStatusCheckState::ScsiCommandFailed(CMassStorageFsm& aFsm)

  1074     {

  1075 	__MSFNLOG

  1076 	aFsm.SetState(ESenseState);

  1077     return KErrNone;

  1078     }

  1079 

  1080 

  1081 /**

  1082 

  1083 */

  1084 TAllowMediumRemovalState::TAllowMediumRemovalState()

  1085 :   TMassStorageState(EAllowRemovalState)

  1086     {

  1087 	__MSFNLOG

  1088     }

  1089 

  1090 

  1091 TMassStorage::TEvent TAllowMediumRemovalState::EntryL(CMassStorageFsm& aFsm)

  1092     {

  1093 	__MSFNLOG

  1094     return aFsm.PreventAllowMediumRemovalL(EFalse);

  1095     }

  1096 

  1097 

  1098 TInt TAllowMediumRemovalState::ScsiCommandPassed(CMassStorageFsm& aFsm)

  1099     {

  1100 	__MSFNLOG

  1101     TInt ret = KErrNone;

  1102     if (aFsm.StartStopUnitRequired())

  1103         {

  1104         aFsm.SetState(TMassStorageState::EStopUnitState);

  1105         }

  1106     else

  1107         {

  1108         aFsm.SetState(ENotReadyState);

  1109         ret = KErrCompletion;

  1110         }

  1111     return ret;

  1112     };

  1113 

  1114 

  1115 TInt TAllowMediumRemovalState::ScsiCommandFailed(CMassStorageFsm& aFsm)

  1116     {

  1117 	__MSFNLOG

  1118     aFsm.SetState(TMassStorageState::EInquiryState);

  1119     return KErrCompletion;

  1120     }

  1121 

  1122 

  1123 /**

  1124 

  1125 */

  1126 TStopUnitState::TStopUnitState()

  1127 :   TMassStorageState(EStopUnitState)

  1128     {

  1129 	__MSFNLOG

  1130     }

  1131 

  1132 

  1133 TMassStorage::TEvent TStopUnitState::EntryL(CMassStorageFsm& aFsm)

  1134     {