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 logical channel.

    16 *

    17 */

    18 

    19 

    20 // INCLUDE FILES 

    21 #include <kern_priv.h>               // class DThread

    22 #include "dmc_extension.h"           // iDmcDfcQueuePtrv

    23 #include "dmc_user_if.h"

    24 #include "dmc_logical_channel.h"

    25 #include "dmc_logical_device.h"

    26 #include "dmc_trace.h"

    27 

    28 #include "osttracedefinitions.h"

    29 #ifdef OST_TRACE_COMPILER_IN_USE

    30 #include "dmc_logical_channelTraces.h"

    31 #endif

    32 

    33 // EXTERNAL DATA STRUCTURES 

    34 // EXTERNAL FUNCTION PROTOTYPES 

    35 // FORWARD DECLARATIONS

    36 // CONSTANTS

    37 // MACROS

    38 // LOCAL CONSTANTS AND MACROS

    39 // MODULE DATA STRUCTURES

    40 

    41 // LOCAL FUNCTION PROTOTYPES  

    42 

    43 

    44 // ==================== LOCAL FUNCTIONS ====================

    45 // ================= OTHER EXPORTED FUNCTIONS ==============

    46 

    47 // ================= MEMBER FUNCTIONS =======================

    48 

    49 //-----------------------------------------------------------

    50 //  DDmcLogicalChannel::DDmcLogicalChannel

    51 //-----------------------------------------------------------

    52 DDmcLogicalChannel::DDmcLogicalChannel(DLogicalDevice* aLogicalDevicePtr)

    53     : DLogicalChannel()

    54     , iDmcLogicalDevPtr(NULL)

    55     , iClientThreadPtr(NULL)

    56     , iClientStatusPtr(NULL)

    57     , iClientEventBufferPtr(NULL)

    58     {

    59     OstTrace1(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_DDMC_LOGICAL_CHANNEL_ENTRY,

    60               "DMC:LOGIC_CHNL: DDmcLogicalChannel() # IN - aLogicalDevicePtr, 0x%x:",

    61               aLogicalDevicePtr);

    62     DMC_TRACE((("DMC:LOGIC_CHNL: DDmcLogicalChannel() # IN - aLogicalDevicePtr, 0x%x:"),

    63                  aLogicalDevicePtr));

    64 

    65     DMC_TRACE_ASSERT(aLogicalDevicePtr);

    66 

    67     iDmcLogicalDevPtr = reinterpret_cast<DDmcLogicalDevice*>(aLogicalDevicePtr);

    68 

    69     iClientThreadPtr  = &Kern::CurrentThread();

    70     TInt result = ((DObject*)iClientThreadPtr)->Open();

    71 

    72     DMC_TRACE_ASSERT(result == KErrNone);

    73 

    74     OstTrace0(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_DDMC_LOGICAL_CHANNEL_RETURN,

    75               "DMC:LOGIC_CHNL: DDmcLogicalChannel() # OUT");

    76     DMC_TRACE(("DMC:LOGIC_CHNL: DDmcLogicalChannel() # OUT"));

    77     }

    78 

    79 

    80 //-----------------------------------------------------------

    81 //  DDmcLogicalChannel::~DDmcLogicalChannel

    82 //-----------------------------------------------------------

    83 DDmcLogicalChannel::~DDmcLogicalChannel()

    84     {

    85     OstTrace0(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL__DDMC_LOGICAL_CHANNEL_ENTRY,

    86               "DMC:LOGIC_CHNL: ~DDmcLogicalChannel() # IN");

    87     DMC_TRACE(("DMC:LOGIC_CHNL: ~DDmcLogicalChannel() # IN"));

    88 

    89     // Calling of Kern::SafeClose must be in a critical section 

    90     NKern::ThreadEnterCS();

    91 

    92     OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DDMC_LOGICAL_CHANNEL_1,

    93               "DMC:LOGIC_CHNL: ~DDmcLogicalChannel() - call Kern::SafeClose");

    94     DMC_TRACE(("DMC:LOGIC_CHNL: ~DDmcLogicalChannel() - call Kern::SafeClose"));

    95 

    96     // Close our reference on the client thread

    97     Kern::SafeClose((DObject*&)iClientThreadPtr, NULL);

    98 

    99     NKern::ThreadLeaveCS();

   100 

   101     // Cancel reset and power off events

   102     iDmcLogicalDevPtr->UnsubscribeEvents(this);

   103 

   104     if (iDmcLogicalDevPtr)

   105         {

   106         iDmcLogicalDevPtr = NULL;

   107         }

   108     

   109     if (iClientThreadPtr)

   110         {

   111         iClientThreadPtr = NULL;

   112         }

   113     

   114     if (iClientStatusPtr)

   115         {

   116         iClientStatusPtr = NULL;

   117         }

   118 

   119     if (iClientEventBufferPtr)

   120         {

   121         iClientEventBufferPtr = NULL;

   122         }

   123     

   124     OstTrace0(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL__DDMC_LOGICAL_CHANNEL_RETURN,

   125               "DMC:LOGIC_CHNL: ~DDmcLogicalChannel() # OUT");

   126     DMC_TRACE(("DMC:LOGIC_CHNL: ~DDmcLogicalChannel() # OUT"));

   127     }

   128 

   129 

   130 // -----------------------------------------------------------------------------

   131 // DDmcLogicalChannel::DoCreate

   132 // -----------------------------------------------------------------------------

   133 TInt DDmcLogicalChannel::DoCreate(TInt /* aUnit */, const TDesC8*  /* aInfo */, const TVersion& aVer)

   134     {

   135     OstTrace1(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_DO_CREATE_ENTRY,

   136               "DMC:LOGIC_CHNL: DoCreate() # IN - aVer: 0x%x", (TUint)&(aVer));

   137     DMC_TRACE((("DMC:LOGIC_CHNL: DoCreate() # IN - aVer: 0x%x "), &aVer));

   138 

   139     TInt retVal(KErrNone);

   140 

   141     // capability security check

   142     if (!Kern::CurrentThreadHasCapability(ECapabilityCommDD, 

   143                                           __PLATSEC_DIAGNOSTIC_STRING("Checked by dmc.ldd") ) )

   144         {

   145         DMC_TRACE_ALWAYS_ASSERT;

   146 

   147         retVal = KErrPermissionDenied;

   148         }

   149 

   150     // Check version

   151     if (retVal == KErrNone)

   152         {

   153         if (!Kern::QueryVersionSupported(TVersion(RDmc::EMajorVersionNumber,

   154                                                   RDmc::EMinorVersionNumber,

   155                                                   RDmc::EBuildVersionNumber),

   156                                                   aVer))

   157             {

   158             OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CREATE_1,

   159                       "DMC:LOGIC_CHNL: DoCreate() - KErrNotSupported");

   160             DMC_TRACE_ALWAYS_ASSERT;

   161 

   162             retVal = KErrNotSupported;

   163             }

   164         }

   165 

   166     // check user's Vendor ID to ensure that only known client are accessing

   167     if (retVal == KErrNone)

   168         {

   169         TUint32 vendorId = Kern::CurrentThread().iOwningProcess->iS.iVendorId;

   170 

   171         OstTrace1(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CREATE_2,

   172                   "DMC:LOGIC_CHNL: DoCreate() - vendorId: 0x%x", vendorId);

   173         DMC_TRACE((("DMC:LOGIC_CHNL: DoCreate() - vendorId: 0x%x "), vendorId));

   174 

   175         if (vendorId != VID_DEFAULT)

   176             {   

   177             OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CREATE_3,

   178                       "DMC:LOGIC_CHNL: DoCreate() - VID check FAILED !");

   179             DMC_TRACE(("DMC:LOGIC_CHNL: DoCreate() - VID check FAILED !"));

   180 

   181             DMC_TRACE_ALWAYS_ASSERT;

   182 

   183             retVal = KErrAccessDenied;

   184             }

   185         }

   186 

   187     // Initialize DFC queue

   188     DMC_TRACE_ASSERT_RESET(iDmcLogicalDevPtr->GetDynamicDfcQueue(),

   189                            "DMC:LOGIC_CHNL: DoCreate() - iDmcLogicalDevPtr->GetDynamicDfcQueue()",

   190                            KErrNoMemory);

   191 

   192     SetDfcQ(iDmcLogicalDevPtr->GetDynamicDfcQueue());

   193     iMsgQ.Receive();

   194 

   195     OstTrace1(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_DO_CREATE_RETURN,

   196               "DMC:LOGIC_CHNL: DoCreate() # OUT - retVal: %d", retVal);

   197     DMC_TRACE((("DMC:LOGIC_CHNL: DoCreate() # OUT - retVal: %d "), retVal));

   198     

   199     return retVal;

   200     }

   201 

   202 

   203 // ---------------------------------------------------------

   204 // DDmcLogicalChannel::HandleMsg

   205 // ---------------------------------------------------------

   206 void DDmcLogicalChannel::HandleMsg(TMessageBase* aMsg)

   207     {

   208     OstTrace1(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_HANDLE_MSG_ENTRY,

   209               "DMC:LOGIC_CHNL: HandleMsg() # IN - aMsg: 0x%x",

   210               (TUint)(aMsg));

   211     DMC_TRACE((("DMC:LOGIC_CHNL: HandleMsg() # IN - aMsg: 0x%x "), aMsg));

   212 

   213     DMC_TRACE_ASSERT_RESET(aMsg,

   214                            "DMC:LOGIC_CHNL: HandleMsg() - aMsg",

   215                            KErrNoMemory);

   216 

   217     TThreadMessage& m = *reinterpret_cast<TThreadMessage*>(aMsg);

   218 

   219     // Get message type

   220     TInt msgId(m.iValue);

   221 

   222     OstTrace1(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_HANDLE_MSG_1,

   223               "DMC:LOGIC_CHNL: HandleMsg() - msgId: 0x%x",

   224               (TUint)(msgId));

   225     DMC_TRACE((("DMC:LOGIC_CHNL: HandleMsg() - msgId: 0x%x "), msgId));

   226 

   227     // close request

   228     if (msgId == static_cast<TInt>(ECloseMsg))

   229         {

   230         OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_HANDLE_MSG_3,

   231                   "DMC:LOGIC_CHNL: HandleMsg() - ECloseMsg");

   232         DMC_TRACE(("DMC:LOGIC_CHNL: HandleMsg() - ECloseMsg)"));

   233 

   234         m.Complete(KErrNone, EFalse);

   235         }

   236     else if (msgId == KMaxTInt)

   237         {

   238         // cancel request

   239         OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_HANDLE_MSG_4,

   240                   "DMC:LOGIC_CHNL: HandleMsg() - KMaxTInt, DoCancel");

   241         DMC_TRACE(("DMC:LOGIC_CHNL: HandleMsg() - KMaxTInt, DoCancel"));

   242 

   243         m.Complete(KErrNone, ETrue);

   244         }

   245     else if (msgId >= 0)

   246         {

   247         // sync request

   248         OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_HANDLE_MSG_5,

   249                   "DMC:LOGIC_CHNL: HandleMsg() - DoControl");

   250         DMC_TRACE(("DMC:LOGIC_CHNL: HandleMsg() - DoControl"));

   251 

   252         // DoControl

   253         TInt retStatus(DoControl(msgId, m.Ptr0()));

   254         m.Complete(retStatus, ETrue);

   255         }

   256     else

   257         {

   258         // async request

   259         OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_HANDLE_MSG_6,

   260                   "DMC:LOGIC_CHNL: HandleMsg() - DoRequest");

   261         DMC_TRACE(("DMC:LOGIC_CHNL: HandleMsg() - DoRequest"));

   262         

   263         // DoRequest

   264         TRequestStatus* usrReqStatPtr = (TRequestStatus *)m.Ptr0();

   265 

   266         TInt retStatus(DoRequest(~msgId, usrReqStatPtr, m.Ptr1()));

   267 

   268         if (retStatus != KErrNone)

   269             {

   270             Kern::RequestComplete(iClientThreadPtr, usrReqStatPtr, retStatus);

   271             }

   272 

   273         m.Complete(KErrNone, ETrue);

   274         }

   275 

   276     OstTrace0(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_HANDLE_MSG_RETURN,

   277               "DMC:LOGIC_CHNL: HandleMsg() # OUT ");

   278     DMC_TRACE(("DMC:LOGIC_CHNL: HandleMsg() # OUT"));

   279     }

   280 

   281 

   282 // -----------------------------------------------------------------------------

   283 // DDmcLogicalChannel::SendEvent

   284 // -----------------------------------------------------------------------------

   285 void DDmcLogicalChannel::SendEvent(const RDmc::TEvent& aEvent)

   286     {

   287     OstTrace1(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_SEND_EVENT_ENTRY,

   288               "DMC:LOGIC_CHNL: SendEvent() # IN - aEvent: %d", aEvent);

   289     DMC_TRACE((("DMC:LOGIC_CHNL: SendEvent() # IN - aEvent: %d"), aEvent));

   290 

   291     // Make sure that a client has subscribed events.

   292     if (iClientStatusPtr)

   293         {

   294         OstTrace1(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_SEND_1,

   295                   "DMC:LOGIC_CHNL: SendEvent() - KErrNone: %d", KErrNone);

   296         DMC_TRACE((("DMC:LOGIC_CHNL: SendEvent() - KErrNone: %d"), KErrNone));

   297 

   298         TInt retStatus = Kern::ThreadRawWrite(iClientThreadPtr,

   299                                               iClientEventBufferPtr,

   300                                               &aEvent,

   301                                               sizeof(aEvent));

   302 

   303         OstTrace1(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_SEND_EVENT_1,

   304               "DMC:LOGIC_CHNL: SendEvent() # IN - retStatus: %d", retStatus);

   305         DMC_TRACE((("DMC:LOGIC_CHNL: SendEvent() # IN - retStatus: %d, iClientStatusPtr: 0x%x"),

   306                      retStatus, iClientStatusPtr));

   307 

   308         Kern::RequestComplete(iClientThreadPtr, iClientStatusPtr, retStatus);

   309         }

   310 

   311     OstTrace0(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_SEND_EVENT_RETURN,

   312               "DMC:LOGIC_CHNL: SendEvent() # OUT ");

   313     DMC_TRACE(("DMC:LOGIC_CHNL: SendEvent() # OUT"));

   314     }

   315 

   316 

   317 // -----------------------------------------------------------------------------

   318 // DDmcLogicalChannel::DoControl

   319 // -----------------------------------------------------------------------------

   320 TInt DDmcLogicalChannel::DoControl(const TInt aFunction, TAny* a1)

   321     {

   322     OstTraceExt2(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_DO_CONTROL_ENTRY,

   323                  "DMC:LOGIC_CHNL: DoControl() # IN - aFunction: 0x%x, a1: 0x%x",

   324                  (TUint)(aFunction), (TUint)(a1));

   325     DMC_TRACE((("DMC:LOGIC_CHNL: DoControl() # IN - aFunction: 0x%x, a1: 0x%x"), aFunction, a1));

   326 

   327     TInt retStatus(KErrBadHandle);

   328 

   329     if (iDmcLogicalDevPtr)

   330         {

   331         retStatus = KErrNone;

   332 

   333         switch (aFunction)

   334             {

   335             case RDmc::EGetTargetStartUpMode:

   336                 {

   337                 OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CONTROL_1,

   338                          "DMC:LOGIC_CHNL: DoControl() - EGetTargetStartUpMode");

   339                 DMC_TRACE(("DMC:LOGIC_CHNL: DoControl() - EGetTargetStartUpMode"));

   340 

   341                 RDmc::TTargetStartupMode targetStartUpMode;

   342 

   343                 retStatus = iDmcLogicalDevPtr->GetTargetStartUpMode(targetStartUpMode);

   344 

   345                 DMC_TRACE_ASSERT(retStatus == KErrNone);

   346 

   347                 if (retStatus == KErrNone)

   348                     {

   349                     retStatus = Kern::ThreadRawWrite(iClientThreadPtr,

   350                                                      a1,

   351                                                      &targetStartUpMode,

   352                                                      sizeof(targetStartUpMode));

   353             

   354                     OstTraceExt2(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CONTROL_2,

   355                                  "DMC:LOGIC_CHNL: DoControl() - retStatus: %d, targetStartUpMode: %d",

   356                                  retStatus, targetStartUpMode);

   357                     DMC_TRACE((("DMC:LOGIC_CHNL: DoControl() - retStatus: %d, targetStartUpMode: %d"),

   358                                  retStatus, targetStartUpMode));

   359                     }

   360                 }

   361                 break;

   362 

   363             case RDmc::EGenerateReset:

   364                 {

   365                 OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CONTROL_3,

   366                          "DMC:LOGIC_CHNL: DoControl() - EGenerateReset");

   367                 DMC_TRACE(("DMC:LOGIC_CHNL: DoControl() - EGenerateReset"));

   368 

   369                 RDmc::TTargetStartupMode targetStartUpMode;

   370 

   371                 retStatus = Kern::ThreadRawRead(iClientThreadPtr,

   372                                                 a1,

   373                                                 &targetStartUpMode,

   374                                                 sizeof(targetStartUpMode));

   375 

   376                 DMC_TRACE_ASSERT(retStatus == KErrNone);

   377                 OstTraceExt2(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CONTROL_4,

   378                              "DMC:LOGIC_CHNL: DoControl() - retStatus: %d, targetStartUpMode: %d",

   379                              retStatus, targetStartUpMode);

   380                 DMC_TRACE((("DMC:LOGIC_CHNL: DoControl() - retStatus: %d, targetStartUpMode: %d"),

   381                              retStatus, targetStartUpMode));

   382 

   383                 if (retStatus == KErrNone)

   384                     {

   385                     retStatus = iDmcLogicalDevPtr->GenerateReset(targetStartUpMode);

   386                     }

   387 

   388                 DMC_TRACE_ASSERT(retStatus == KErrNone);

   389                 }

   390                 break;

   391 

   392             case RDmc::EPowerOff:

   393                 {

   394                 OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CONTROL_5,

   395                          "DMC:LOGIC_CHNL: DoControl() - EPowerOff");

   396                 DMC_TRACE(("DMC:LOGIC_CHNL: DoControl() - EPowerOff"));

   397 

   398                 retStatus = iDmcLogicalDevPtr->PowerOff();

   399 

   400                 DMC_TRACE_ASSERT(retStatus == KErrNone);

   401                 }

   402                 break;

   403 

   404 

   405             case RDmc::EIsHiddenReset:

   406                 {

   407                 OstTrace0(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CONTROL_6,

   408                          "DMC:LOGIC_CHNL: DoControl() - EIsHiddenReset");

   409                 DMC_TRACE(("DMC:LOGIC_CHNL: DoControl() - EIsHiddenReset"));

   410 

   411                 TBool hiddenStatus;

   412 

   413                 retStatus = iDmcLogicalDevPtr->IsHiddenReset(hiddenStatus);

   414 

   415                 DMC_TRACE_ASSERT(retStatus == KErrNone);

   416 

   417                 if (retStatus == KErrNone)

   418                     {

   419                     retStatus = Kern::ThreadRawWrite(iClientThreadPtr,

   420                                                      a1,

   421                                                      &hiddenStatus,

   422                                                      sizeof(hiddenStatus));

   423             

   424                     OstTraceExt2(TRACE_FLOW, DDMC_LOGICAL_CHANNEL_DO_CONTROL_7,

   425                                  "DMC:LOGIC_CHNL: DoControl() - retStatus: %d, hiddenStatus: %d",

   426                                  retStatus, hiddenStatus);

   427                     DMC_TRACE((("DMC:LOGIC_CHNL: DoControl() - retStatus: %d, hiddenStatus: %d"),

   428                                  retStatus, hiddenStatus));

   429                     }

   430                 }

   431                 break;

   432 

   433             default:

   434                 {

   435                 DMC_TRACE_ALWAYS_ASSERT;

   436 

   437                 retStatus = KErrNotSupported;

   438                 }

   439                 break;

   440             }

   441         }

   442 

   443     OstTrace1(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_DO_CONTROL_RETURN,

   444               "DMC:LOGIC_CHNL: DoControl() # OUT - retStatus %d:", retStatus);

   445     DMC_TRACE((("DMC:LOGIC_CHNL: DoControl() # OUT - retStatus: %d"), retStatus));

   446     

   447     return retStatus;

   448     }

   449 

   450 

   451 // -----------------------------------------------------------------------------

   452 // DDmcLogicalChannel::DoRequest

   453 // -----------------------------------------------------------------------------

   454 TInt DDmcLogicalChannel::DoRequest(const TInt aReqId, TRequestStatus* const aStatusPtr, TAny* const a1)

   455     {

   456     OstTraceExt3(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_DO_REQUEST_ENTRY,

   457                  "DMC:LOGIC_CHNL: DoRequest() # IN - aRegId: 0x%x, aStatusPtr: 0x%x, a1: 0x%x",

   458                  (TUint)(aReqId), (TUint)aStatusPtr, (TUint)(a1));

   459     DMC_TRACE((("DMC:LOGIC_CHNL: DoRequest() # IN - aReqId: 0x%x, aStatusPtr: 0x%x, a1: 0x%x"),

   460                  aReqId, aStatusPtr, a1));

   461     DMC_TRACE_ASSERT_RESET(a1, "DMC:LOG_DEVICE: DDmcLogicalDevice() - a1", KErrNoMemory);

   462 

   463     iClientStatusPtr      = aStatusPtr;

   464     iClientEventBufferPtr = static_cast<RDmc::TEvent*>(a1);

   465 

   466     iDmcLogicalDevPtr->SubscribeEvents(this);

   467 

   468     OstTrace0(TRACE_ENTRY_EXIT, DDMC_LOGICAL_CHANNEL_DO_REQUEST_RETURN,

   469               "DMC:LOGIC_CHNL: DoRequest() # OUT");

   470     DMC_TRACE(("DMC:LOGIC_CHNL: DoRequest() # OUT"));

   471 

   472     return KErrNone;

   473     }

   474 

   475 //  End of File