1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 * 

    14 * Description: 

    15 *     Implementation of DMC tester.

    16 *

    17 */

    18 

    19 

    20 // INCLUDES

    21 #include <e32base.h>        // CActive

    22 #include <e32cons.h>

    23 #include <e32des8.h>

    24 #include <f32file.h>        // RDebug

    25 #include <flogger.h>        // RFileLogger

    26 #include <e32test.h>        // RTest 

    27 

    28 #include "dmc_user_if.h"

    29 

    30 // CONSTANTS

    31 _LIT(KDmcTesterName, "dmc_tester");

    32 

    33 TInt OpenDmc(RDmc& aDmc);

    34 /**

    35  *  Class for receiving events.

    36  */

    37 class CDmcTstEventHandler : public CActive

    38     {

    39     public:

    40         static CDmcTstEventHandler* NewL(RDmc& aDmc);

    41         /**

    42         * C++ default constructor.

    43         */

    44         CDmcTstEventHandler(RDmc& aDmc);

    45 

    46         /**

    47         * Destructor.

    48         */

    49         virtual ~CDmcTstEventHandler();

    50 

    51     private: // From CActive

    52 

    53         void RunL();

    54         void DoCancel();

    55     

    56     private: // Data

    57         RDmc iDmc;

    58         RDmc::TEvent iEvent;

    59     };

    60 

    61 /**

    62  *  Small helper class that hides the interface specific

    63  *  operations and makes the test sequence more readable. 

    64  */

    65 class DmcTester : public CActive

    66     {

    67     public:

    68         static DmcTester* NewL(RDmc& aDmc);

    69         /**

    70         * C++ default constructor.

    71         */

    72         DmcTester(RDmc& aDmc);

    73 

    74         /**

    75         * Destructor.

    76         */

    77         virtual ~DmcTester();

    78         RDmc& Initialize();

    79         void  GetTargetStartUpMode();

    80         void  PowerOff();

    81         void  GenerateReset();

    82         void  GetHiddenResetStatus();

    83         void  AskNextMode();

    84 

    85     private: // From CActive

    86         void RunL();

    87         void DoCancel();

    88 

    89     private: // Data

    90         RDmc iDmc;      // Dmc logical device driver

    91         RTest iTest;    // test app

    92         CConsoleBase* iConsolePtr;

    93     };

    94 

    95 

    96 /**

    97  * Execute tests.

    98  */

    99 void ExecuteDmcTestsL()

   100     {

   101     RDebug::Printf("DMC:TST_TESTER: ExecuteDmcTestsL() # IN");

   102 

   103     // Create the active scheduler

   104     RDebug::Printf("DMC:TST_TESTER: Initialize() - Create activeSchedulerPtr");

   105     CActiveScheduler* activeSchedulerPtr = new (ELeave) CActiveScheduler;

   106     CleanupStack::PushL(activeSchedulerPtr);

   107 

   108     RDebug::Printf("DMC:TST_TESTER: Initialize() - Install activeSchedulerPtr");

   109     CActiveScheduler::Install(activeSchedulerPtr);

   110 

   111     /* Client 1 */

   112     RDmc dmc1;

   113     

   114     RDebug::Printf("DMC:TST_TESTER: ExecuteDmcTestsL() - DmcTester::CDmcTstEventHandler::NewL()");

   115     DmcTester* dmcTesterPtr = DmcTester::NewL(dmc1);

   116     CleanupStack::PushL(dmcTesterPtr);

   117 

   118 #if 0

   119     /* Client 2 for events*/

   120     RDmc dmc2;

   121 

   122     RDebug::Printf("DMC:TST_TESTER: Initialize() - Client 2, CDmcTstEventHandler::NewL()");

   123     CDmcTstEventHandler* eventHandlerPtr = CDmcTstEventHandler::NewL(dmc2);

   124     CleanupStack::PushL(eventHandlerPtr);

   125 

   126     /* Client 3 for events*/

   127     RDmc dmc3;

   128 

   129     RDebug::Printf("DMC:TST_TESTER: Initialize() - Client 3, CDmcTstEventHandler::NewL()");

   130     CDmcTstEventHandler* eventHandlerPtr2 = CDmcTstEventHandler::NewL(dmc3);

   131     CleanupStack::PushL(eventHandlerPtr2);

   132 #endif // 0

   133 

   134     RDebug::Printf("DMC:TST_TESTER: Initialize() - CActiveScheduler::Start()");

   135     CActiveScheduler::Start();

   136     

   137     RDebug::Printf("DMC:TST_TESTER: Initialize() - CleanupStack::PopAndDestroy()");

   138     CleanupStack::PopAndDestroy(2, activeSchedulerPtr);

   139     

   140     RDebug::Printf("DMC:TST_TESTER: ExecuteDmcTestsL() # OUT");

   141     }

   142 

   143 

   144 /**

   145  *  Open RDmc channel

   146  */

   147 TInt OpenDmc(RDmc& aDmc)

   148     {

   149     RDebug::Printf("DMC:TST_TESTER: OpenDmc() # IN");

   150 

   151     TInt err(KErrNone);

   152     

   153     err = aDmc.Open();

   154 

   155     if (err != KErrNone)

   156         {

   157         RDebug::Printf("DMC:TST_TESTER: OpenDmc() - DMC opening Not OK");

   158         aDmc.Close();

   159         }

   160     else

   161         {

   162         RDebug::Printf("DMC:TST_TESTER: OpenDmc() - DMC opening OK");

   163         }

   164    

   165     RDebug::Printf("DMC:TST_TESTER: OpenDmc() # OUT");

   166 

   167     return err;

   168     }

   169 

   170 

   171 /******************************************************

   172  *

   173  *    Implementation of DmcTester.

   174  *   

   175  *

   176  ******************************************************/

   177 

   178 

   179 /**

   180  * Constuctor

   181  */

   182 DmcTester::DmcTester(RDmc& aDmc)

   183     : CActive(CActive::EPriorityStandard)

   184     , iDmc(aDmc)

   185     , iTest(KDmcTesterName)

   186     {

   187     RDebug::Printf("DMC:TST_TESTER: DmcTester::DmcTester() # IN");

   188     iTest.Printf(_L("* DMC_TESTER *\n"));

   189 

   190     RDebug::Printf("DMC:TST_TESTER: DmcTester() - Add()");

   191     CActiveScheduler::Add(this);

   192     

   193     //RDebug::Printf("DMC:TST_TESTER: DmcTester() - iConsolePtr: 0x%x", iConsolePtr);

   194     //CConsoleBase* iConsolePtr = iTest.Console();

   195 

   196     TRequestStatus* statusPtr = &iStatus;

   197 

   198     RDebug::Printf("DMC:TST_TESTER: DmcTester() - *statusPtr: 0x%x", statusPtr);

   199     RDebug::Printf("DMC:TST_TESTER: DmcTester() - User::RequestComplete, KErrNone");

   200     User::RequestComplete(statusPtr, KErrNone);

   201 

   202     if (!IsActive())

   203         {

   204         RDebug::Printf("DMC:TST_TESTER: DmcTester() - SetActive()");

   205         SetActive();

   206         }

   207     else

   208         {

   209         RDebug::Printf("DMC:TST_TESTER: DmcTester() - !IsActive() -> else");    

   210         }

   211 

   212     RDebug::Printf("DMC:TST_TESTER: DmcTester::DmcTester() # OUT");

   213     }

   214  

   215  

   216 /**

   217  *  Constructor

   218  */

   219 DmcTester* DmcTester::NewL(RDmc& aDmc)

   220     {

   221     RDebug::Printf("DMC:TST_TESTER: NewL() # IN");

   222 

   223     RDebug::Printf("DMC:TST_TESTER: NewL() - OpenDmc");

   224     (void)OpenDmc(aDmc);

   225 

   226     DmcTester* self = new (ELeave)DmcTester(aDmc);

   227 

   228     RDebug::Printf("DMC:TST_TESTER: NewL() # OUT");

   229     

   230     return self;

   231     }

   232 

   233  

   234 /**

   235  *  Closes and releases DMC

   236  */

   237 DmcTester::~DmcTester()

   238     {

   239     RDebug::Printf("DMC:TST_TESTER: ~DmcTester() # IN");

   240 

   241     RDebug::Printf("DMC:TST_TESTER: ~DmcTester() - Close()");

   242     iDmc.Close();

   243 

   244     RDebug::Printf("DMC:TST_TESTER: ~DmcTester # OUT");

   245     }

   246 

   247 

   248 /**

   249  *  Ask the target startup mode

   250  */

   251 void DmcTester::GetTargetStartUpMode()

   252     {

   253     RDebug::Printf("DMC:TST_TESTER: GetTargetStartUpMode() # IN");

   254     

   255     RDmc::TTargetStartupMode dmcTargetMode(RDmc::EStartupModeNone);

   256 

   257     RDebug::Printf("DMC:TST_TESTER: GetTargetStartUpMode() - Asking DMC target startup mode");

   258 

   259     TInt err = iDmc.GetStartUpMode(dmcTargetMode);

   260 

   261     if (err == KErrNone)

   262         {

   263         switch(dmcTargetMode)

   264             {

   265             case RDmc::EStartupModeNone:

   266                 {

   267                 iTest.Printf(_L("RDmc::EStartupModeNone\n"));

   268                 }

   269                 break;

   270                 

   271             case RDmc::EStartupModeNormal:

   272                 {

   273                 iTest.Printf(_L("RDmc::EStartupModeNormal\n"));

   274                 }

   275                 break;

   276 

   277             case RDmc::EStartupModeCharging:

   278                 {

   279                 iTest.Printf(_L("RDmc::EStartupModeCharging\n"));

   280                 }

   281                 break;

   282 

   283             case RDmc::EStartupModeAlarm:

   284                 {

   285                 iTest.Printf(_L("RDmc::EStartupModeAlarm\n"));

   286                 }

   287                 break;

   288                 

   289             case RDmc::EStartupModeTest:

   290                 {

   291                 iTest.Printf(_L("RDmc::EStartupModeTest\n"));

   292                 }

   293                 break;

   294 

   295             case RDmc::EStartupModeFota:

   296                 {

   297                 iTest.Printf(_L("RDmc::EStartupModeFota\n"));

   298                 }

   299                 break;

   300 

   301             default:

   302                 iTest.Printf(_L("Unknown starup mode\n"));

   303                 err = KErrGeneral;

   304                 break;

   305             }

   306         }

   307         

   308     if (err)

   309         {

   310         iTest.Printf(_L("Asking target startup mode return error: %d\n"), err);

   311         User::Panic(KDmcTesterName, err);

   312         }

   313 

   314     RDebug::Printf("DMC:TST_TESTER: GetTargetStartUpMode() # OUT");

   315     }

   316 

   317 

   318 /**

   319  *  Power OFF the device

   320  */

   321 

   322 void DmcTester::PowerOff()

   323     {

   324     RDebug::Printf("DMC:TST_TESTER: PowerOff() # IN");

   325 

   326     TInt err = iDmc.PowerOff();

   327     RDebug::Printf("DMC:TST_TESTER: PowerOff() - err: %d", err);

   328 

   329     err = UserHal::SwitchOff();

   330     RDebug::Printf("DMC:TST_TESTER: PowerOff() - UserHal::SwitchOff: %d", err);

   331 

   332     RDebug::Printf("DMC:TST_TESTER: PowerOff() # OUT");

   333     }

   334 

   335 

   336 /**

   337  *  Generate reset

   338  */

   339 

   340 void DmcTester::GenerateReset()

   341     {

   342     RDebug::Printf("DMC:TST_TESTER: GenerateReset() # IN");

   343 

   344     // Generate reset

   345     RDebug::Printf("DMC:TST_TESTER: GenerateReset() - RDmc::EStartupModeTest");

   346 

   347     RDmc::TTargetStartupMode dmcTargetMode(RDmc::EStartupModeTest);

   348 

   349     TInt err = iDmc.GenerateReset(dmcTargetMode);

   350     RDebug::Printf("DMC:TST_TESTER: GenerateReset() - err: %d", err);

   351 

   352     err = UserHal::SwitchOff();

   353     RDebug::Printf("DMC:TST_TESTER: GenerateReset() - UserHal::SwitchOff: %d", err);

   354 

   355     RDebug::Printf("DMC:TST_TESTER: GenerateReset() # OUT");

   356     }

   357     

   358 

   359 

   360 /**

   361  *  Get Hidden Reset Status

   362  */

   363 

   364 void DmcTester::GetHiddenResetStatus()

   365     {

   366     RDebug::Printf("DMC:TST_TESTER: GetHiddenResetStatus() # IN");

   367 

   368     TBool hidden(EFalse);

   369 

   370     TInt err = iDmc.IsHiddenReset(hidden);

   371 

   372     RDebug::Printf("DMC:TST_TESTER: GetHiddenResetStatus() - err: %d, hidden: %d",

   373                     err, hidden);

   374 

   375     RDebug::Printf("DMC:TST_TESTER: GetHiddenResetStatus() # OUT");

   376     }

   377 

   378 

   379 /**

   380  *  Asks next boot mode from user

   381  */

   382 void DmcTester::AskNextMode()

   383     {

   384     RDebug::Printf("DMC:TST_TESTER: AskNextMode() # IN");

   385 

   386     iTest.Printf(_L("\nGive test case number."));

   387     iTest.Printf(_L("\n%d: Get Start-up Mode"),       1);

   388     iTest.Printf(_L("\n%d: Power OFF"),               2);

   389     iTest.Printf(_L("\n%d: Generate Reset"),          3);

   390     iTest.Printf(_L("\n%d: Get Hidden Reset Status"), 4);

   391     iTest.Printf(_L("\n%d: Quit"),                    0);

   392 

   393     TUint menu_choice = (TUint)iTest.Getch();

   394     

   395     // ascii to decimal translation:

   396     if (menu_choice >= 0x30)

   397         {

   398         menu_choice -= 0x30;

   399         }

   400 

   401     switch (menu_choice)

   402         {

   403         case 1: 

   404             {

   405             iTest.Printf(_L("Get Start-up Mode\n\n"));

   406             GetTargetStartUpMode();

   407             }

   408             break;

   409 

   410         case 2:

   411             {

   412             iTest.Printf(_L("Power OFF\n\n"));

   413             PowerOff();

   414             }

   415             break;

   416 

   417         case 3:

   418             {

   419             iTest.Printf(_L("Generate Reset\n\n"));

   420             GenerateReset();

   421             }

   422             break;

   423 

   424         case 4:

   425             {

   426             iTest.Printf(_L("Get Hidden Reset Status\n\n"));

   427             GetHiddenResetStatus();

   428             }

   429             break;

   430 

   431         case 0:

   432             {

   433             iTest.Printf(_L("Quit\n\n"));

   434             }

   435             break;

   436 

   437         default:

   438             {

   439             iTest.Printf(_L("Pressed 0x%02x (not supported)\n\n"), menu_choice);

   440             }

   441             break;

   442         }

   443 

   444     TRequestStatus* statusPtr = &iStatus;

   445 

   446     if (menu_choice == 0)

   447         {

   448         RDebug::Printf("DMC:TST_TESTER: AskNextMode(), Test finished");

   449         RDebug::Printf("DMC:TST_TESTER: AskNextMode() - User::RequestComplete(), KErrGeneral");

   450         User::RequestComplete(statusPtr, KErrGeneral);

   451         }

   452     else

   453         {

   454         RDebug::Printf("DMC:TST_TESTER: AskNextMode() - User::RequestComplete(), KErrNone");

   455         User::RequestComplete(statusPtr, KErrNone);

   456         }

   457 

   458     RDebug::Printf("DMC:TST_TESTER: AskNextMode() # OUT");

   459     }

   460 

   461 

   462 /**

   463  *  RunL()

   464  */

   465 void DmcTester::RunL()

   466     {

   467     RDebug::Printf("DMC:TST_TESTER: RunL() # IN");

   468  

   469     RDebug::Printf("DMC:TST_TESTER: RunL() - iStatus.Int(): %d",

   470                     iStatus.Int());

   471     RDebug::Printf("DMC:TST_TESTER: RunL() - &iStatus: 0x%x", &iStatus);

   472 

   473     switch (iStatus.Int())

   474         {

   475         case KErrNone:

   476             {

   477             RDebug::Printf("DMC:TST_TESTER: RunL() - KErrNone");

   478             // Show menu and ask a next test step

   479             AskNextMode();

   480             //TKeyCode keyCode = iConsolePtr->KeyCode();

   481             //RDebug::Printf("DMC:TST_TESTER: RunL() - keyCode: 0x%x", keyCode);

   482             

   483             //TText8 ch = (TText8)keyCode & 0xFF;

   484             //TText8 ch = iConsolePtr->Getch();

   485             //RDebug::Printf("DMC:TST_TESTER: RunL() - ch: 0x%x", ch);

   486 

   487             // Continue receiving events

   488             RDebug::Printf("DMC:TST_TESTER: RunL() - SetActive()");

   489             SetActive();

   490             }

   491             break;

   492 

   493         case KErrGeneral:

   494             {

   495             RDebug::Printf("DMC:TST_TESTER: RunL - CActiveScheduler::Stop()");

   496             CActiveScheduler::Stop();

   497             }

   498             break;

   499 

   500         default:

   501             {

   502             RDebug::Printf("DMC:TST_TESTER: RunL - default");

   503             }

   504             break;

   505         }

   506 

   507     RDebug::Printf("DMC:TST_TESTER: RunL # OUT");

   508     }

   509 

   510 

   511 /**

   512  *  DoCancel()

   513  */

   514 void DmcTester::DoCancel()

   515     {

   516     RDebug::Printf("DMC:TST_TESTER: DoCancel() - # IN");

   517 

   518     RDebug::Printf("DMC:TST_TESTER: DoCancel() - # OUT");

   519     }

   520 

   521 /******************************************************

   522  *

   523  *    Implementation of CDmcTstEventHandler.

   524  *    Handles DMC events.

   525  *

   526  ******************************************************/

   527 

   528  

   529 /**

   530  *  Default constructor

   531  */

   532 CDmcTstEventHandler::CDmcTstEventHandler(RDmc& aDmc)

   533     : CActive(CActive::EPriorityStandard)

   534     , iDmc(aDmc)

   535     {

   536     RDebug::Printf("DMC:TST_EVHAND: CDmcTstEventHandler() # IN");

   537  

   538     RDebug::Printf("DMC:TST_EVHAND: CDmcTstEventHandler() - Add()");

   539     CActiveScheduler::Add(this);

   540 

   541     // Subscribe events

   542     RDebug::Printf("DMC:TST_EVHAND: CDmcTstEventHandler - ReceiveEvents(), iStatus: 0x%x", &iStatus);

   543     iDmc.ReceiveEvents(iStatus, iEvent);

   544 

   545     if (!IsActive())

   546         {

   547         RDebug::Printf("DMC:TST_EVHAND: CDmcTstEventHandler() - SetActive()");

   548         SetActive();

   549         }

   550     else

   551         {

   552         RDebug::Printf("DMC:TST_EVHAND: CDmcTstEventHandler() - !IsActive() -> else");    

   553         }

   554 

   555     RDebug::Printf("DMC:TST_EVHAND: CDmcTstEventHandler() # OUT");

   556     }

   557 

   558 

   559 /**

   560  *  Constructor

   561  */

   562 CDmcTstEventHandler* CDmcTstEventHandler::NewL(RDmc& aDmc)

   563     {

   564     RDebug::Printf("DMC:TST_EVHAND: NewL() # IN");

   565 

   566     RDebug::Printf("DMC:TST_EVHAND: NewL() - OpenDmc");

   567     (void)OpenDmc(aDmc);

   568 

   569     CDmcTstEventHandler* self = new (ELeave)CDmcTstEventHandler(aDmc);

   570 

   571     RDebug::Printf("DMC:TST_EVHAND: NewL() # OUT");

   572     

   573     return self;

   574     }

   575  

   576  

   577 /**

   578  *  Destructor

   579  */

   580 CDmcTstEventHandler::~CDmcTstEventHandler()

   581     {

   582     RDebug::Printf("DMC:TST_EVHAND: ~CDmcTstEventHandler() # IN");

   583  

   584     RDebug::Printf("DMC:TST_EVHAND: RunL - CActiveScheduler::Cancel()");

   585     Cancel();

   586 

   587     RDebug::Printf("DMC:TST_EVHAND: ~CDmcTstEventHandler() # OUT");

   588     }

   589 

   590 

   591 /**

   592  *  RunL()

   593  */

   594 void CDmcTstEventHandler::RunL()

   595     {

   596     RDebug::Printf("DMC:TST_EVHAND: RunL() # IN");

   597 

   598     RDebug::Printf("DMC:TST_EVHAND: RunL() - iStatus.Int(): %d, iEvent: %d",

   599                     iStatus.Int(), iEvent);

   600     RDebug::Printf("DMC:TST_EVHAND: CDmcTstEventHandler() - &iStatus: 0x%x", &iStatus);

   601 

   602     switch (iStatus.Int())

   603         {

   604         case KErrNone:

   605             {

   606             if (iEvent == RDmc::EResetEvent)

   607                 {

   608                 RDebug::Printf("DMC:TST_EVHAND: RunL() - RDmc::EResetEvent");

   609                 }

   610 

   611             if (iEvent == RDmc::EPowerOffEvent)

   612                 {

   613                 RDebug::Printf("DMC:TST_EVHAND: RunL() - RDmc::EPowerOffEvent");

   614                 }

   615 

   616             RDebug::Printf("DMC:TST_EVHAND: RunL() - UserHal::SwitchOff()");

   617 

   618             // Make switch off both in case of reset and power off

   619             TInt err = UserHal::SwitchOff();

   620             }

   621             break;

   622 

   623         default:

   624             {

   625             RDebug::Printf("DMC:TST_EVHAND: RunL - default");

   626             }

   627             break;

   628         }

   629  

   630 #if 0 

   631     TRequestStatus& status    = iStatus;

   632     TRequestStatus* statusPtr = &status;

   633     User::RequestComplete(statusPtr, KErrNone);

   634 #endif // 0

   635 

   636     // Continue receiving events

   637     RDebug::Printf("DMC:TST_EVHAND: RunL - SetActive()");

   638     SetActive();

   639 

   640     RDebug::Printf("DMC:TST_EVHAND: RunL # OUT");

   641     }

   642 

   643 

   644 /**

   645  *  DoCancel()

   646  */

   647 void CDmcTstEventHandler::DoCancel()

   648     {

   649     RDebug::Printf("DMC:TST_EVHAND: DoCancel() - # IN");

   650  

   651     RDebug::Printf("DMC:TST_EVHAND: DoCancel() - # OUT");

   652     }

   653 

   654 

   655 

   656 /**

   657  * The main entrypoint for application

   658  */

   659 GLDEF_C TInt E32Main()

   660     {

   661     RDebug::Printf("DMC:TST_TESTER: E32Main\n");

   662 

   663     __UHEAP_MARK;

   664     

   665      // get clean-up stack

   666     CTrapCleanup* cleanupPtr = CTrapCleanup::New();

   667 

   668     // start scheduler 

   669     TRAPD(error, ExecuteDmcTestsL());

   670 

   671     // destroy a clean-up stack

   672     delete cleanupPtr;

   673     __UHEAP_MARKEND;

   674 

   675     return error;

   676     }

   677 

   678 // End of File