drivers/staging/epl/EplNmtMnu.c

   1 /****************************************************************************
   2
   3   (c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29
   4       www.systec-electronic.com
   5
   6   Project:      openPOWERLINK
   7
   8   Description:  source file for NMT-MN-Module
   9
  10   License:
  11
  12     Redistribution and use in source and binary forms, with or without
  13     modification, are permitted provided that the following conditions
  14     are met:
  15
  16     1. Redistributions of source code must retain the above copyright
  17        notice, this list of conditions and the following disclaimer.
  18
  19     2. Redistributions in binary form must reproduce the above copyright
  20        notice, this list of conditions and the following disclaimer in the
  21        documentation and/or other materials provided with the distribution.
  22
  23     3. Neither the name of SYSTEC electronic GmbH nor the names of its
  24        contributors may be used to endorse or promote products derived
  25        from this software without prior written permission. For written
  26        permission, please contact info@systec-electronic.com.
  27
  28     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  29     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  30     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  31     FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  32     COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  33     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  34     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  35     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  36     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  37     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  38     ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  39     POSSIBILITY OF SUCH DAMAGE.
  40
  41     Severability Clause:
  42
  43         If a provision of this License is or becomes illegal, invalid or
  44         unenforceable in any jurisdiction, that shall not affect:
  45         1. the validity or enforceability in that jurisdiction of any other
  46            provision of this License; or
  47         2. the validity or enforceability in other jurisdictions of that or
  48            any other provision of this License.
  49
  50   -------------------------------------------------------------------------
  51
  52                 $RCSfile: EplNmtMnu.c,v $
  53
  54                 $Author: D.Krueger $
  55
  56                 $Revision: 1.18 $  $Date: 2008/11/19 09:52:24 $
  57
  58                 $State: Exp $
  59
  60                 Build Environment:
  61                     GCC V3.4
  62
  63   -------------------------------------------------------------------------
  64
  65   Revision History:
  66
  67   2006/06/09 k.t.:   start of the implementation
  68
  69 ****************************************************************************/
  70
  71 #include "user/EplNmtMnu.h"
  72 #include "user/EplTimeru.h"
  73 #include "user/EplIdentu.h"
  74 #include "user/EplStatusu.h"
  75 #include "user/EplObdu.h"
  76 #include "user/EplDlluCal.h"
  77 #include "Benchmark.h"
  78
  79 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
  80
  81 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDU)) == 0) && (EPL_OBD_USE_KERNEL == FALSE)
  82 #error "EPL NmtMnu module needs EPL module OBDU or OBDK!"
  83 #endif
  84
  85 //=========================================================================//
  86 //                                                                         //
  87 //          P R I V A T E   D E F I N I T I O N S                          //
  88 //                                                                         //
  89 //=========================================================================//
  90
  91 //---------------------------------------------------------------------------
  92 // const defines
  93 //---------------------------------------------------------------------------
  94
  95 // TracePoint support for realtime-debugging
  96 #ifdef _DBG_TRACE_POINTS_
  97 void TgtDbgSignalTracePoint(u8 bTracePointNumber_p);
  98 void TgtDbgPostTraceValue(u32 dwTraceValue_p);
  99 #define TGT_DBG_SIGNAL_TRACE_POINT(p)   TgtDbgSignalTracePoint(p)
 100 #define TGT_DBG_POST_TRACE_VALUE(v)     TgtDbgPostTraceValue(v)
 101 #else
 102 #define TGT_DBG_SIGNAL_TRACE_POINT(p)
 103 #define TGT_DBG_POST_TRACE_VALUE(v)
 104 #endif
 105 #define EPL_NMTMNU_DBG_POST_TRACE_VALUE(Event_p, uiNodeId_p, wErrorCode_p) \
 106     TGT_DBG_POST_TRACE_VALUE((kEplEventSinkNmtMnu << 28) | (Event_p << 24) \
 107                              | (uiNodeId_p << 16) | wErrorCode_p)
 108
 109 // defines for flags in node info structure
 110 #define EPL_NMTMNU_NODE_FLAG_ISOCHRON       0x0001      // CN is being accessed isochronously
 111 #define EPL_NMTMNU_NODE_FLAG_NOT_SCANNED    0x0002      // CN was not scanned once -> decrement SignalCounter and reset flag
 112 #define EPL_NMTMNU_NODE_FLAG_HALTED         0x0004      // boot process for this CN is halted
 113 #define EPL_NMTMNU_NODE_FLAG_NMT_CMD_ISSUED 0x0008      // NMT command was just issued, wrong NMT states will be tolerated
 114 #define EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ  0x0300      // counter for StatusRequest timer handle
 115 #define EPL_NMTMNU_NODE_FLAG_COUNT_LONGER   0x0C00      // counter for longer timeouts timer handle
 116 #define EPL_NMTMNU_NODE_FLAG_INC_STATREQ    0x0100      // increment for StatusRequest timer handle
 117 #define EPL_NMTMNU_NODE_FLAG_INC_LONGER     0x0400      // increment for longer timeouts timer handle
 118                     // These counters will be incremented at every timer start
 119                     // and copied to timerarg. When the timer event occures
 120                     // both will be compared and if unequal the timer event
 121                     // will be discarded, because it is an old one.
 122
 123 // defines for timer arguments to draw a distinction between serveral events
 124 #define EPL_NMTMNU_TIMERARG_NODE_MASK   0x000000FFL     // mask that contains the node-ID
 125 #define EPL_NMTMNU_TIMERARG_IDENTREQ    0x00010000L     // timer event is for IdentRequest
 126 #define EPL_NMTMNU_TIMERARG_STATREQ     0x00020000L     // timer event is for StatusRequest
 127 #define EPL_NMTMNU_TIMERARG_LONGER      0x00040000L     // timer event is for longer timeouts
 128 #define EPL_NMTMNU_TIMERARG_STATE_MON   0x00080000L     // timer event for StatusRequest to monitor execution of NMT state changes
 129 #define EPL_NMTMNU_TIMERARG_COUNT_SR    0x00000300L     // counter for StatusRequest
 130 #define EPL_NMTMNU_TIMERARG_COUNT_LO    0x00000C00L     // counter for longer timeouts
 131                     // The counters must have the same position as in the node flags above.
 132
 133 #define EPL_NMTMNU_SET_FLAGS_TIMERARG_STATREQ(pNodeInfo_p, uiNodeId_p, TimerArg_p) \
 134     pNodeInfo_p->m_wFlags = \
 135         ((pNodeInfo_p->m_wFlags + EPL_NMTMNU_NODE_FLAG_INC_STATREQ) \
 136          & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ) \
 137         | (pNodeInfo_p->m_wFlags & ~EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ); \
 138     TimerArg_p.m_ulArg = EPL_NMTMNU_TIMERARG_STATREQ | uiNodeId_p | \
 139         (pNodeInfo_p->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ); \
 140     TimerArg_p.m_EventSink = kEplEventSinkNmtMnu;
 141
 142 #define EPL_NMTMNU_SET_FLAGS_TIMERARG_IDENTREQ(pNodeInfo_p, uiNodeId_p, TimerArg_p) \
 143     pNodeInfo_p->m_wFlags = \
 144         ((pNodeInfo_p->m_wFlags + EPL_NMTMNU_NODE_FLAG_INC_STATREQ) \
 145          & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ) \
 146         | (pNodeInfo_p->m_wFlags & ~EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ); \
 147     TimerArg_p.m_ulArg = EPL_NMTMNU_TIMERARG_IDENTREQ | uiNodeId_p | \
 148         (pNodeInfo_p->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ); \
 149     TimerArg_p.m_EventSink = kEplEventSinkNmtMnu;
 150
 151 #define EPL_NMTMNU_SET_FLAGS_TIMERARG_LONGER(pNodeInfo_p, uiNodeId_p, TimerArg_p) \
 152     pNodeInfo_p->m_wFlags = \
 153         ((pNodeInfo_p->m_wFlags + EPL_NMTMNU_NODE_FLAG_INC_LONGER) \
 154          & EPL_NMTMNU_NODE_FLAG_COUNT_LONGER) \
 155         | (pNodeInfo_p->m_wFlags & ~EPL_NMTMNU_NODE_FLAG_COUNT_LONGER); \
 156     TimerArg_p.m_ulArg = EPL_NMTMNU_TIMERARG_LONGER | uiNodeId_p | \
 157         (pNodeInfo_p->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_LONGER); \
 158     TimerArg_p.m_EventSink = kEplEventSinkNmtMnu;
 159
 160 #define EPL_NMTMNU_SET_FLAGS_TIMERARG_STATE_MON(pNodeInfo_p, uiNodeId_p, TimerArg_p) \
 161     pNodeInfo_p->m_wFlags = \
 162         ((pNodeInfo_p->m_wFlags + EPL_NMTMNU_NODE_FLAG_INC_STATREQ) \
 163          & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ) \
 164         | (pNodeInfo_p->m_wFlags & ~EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ); \
 165     TimerArg_p.m_ulArg = EPL_NMTMNU_TIMERARG_STATE_MON | uiNodeId_p | \
 166         (pNodeInfo_p->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ); \
 167     TimerArg_p.m_EventSink = kEplEventSinkNmtMnu;
 168
 169 // defines for global flags
 170 #define EPL_NMTMNU_FLAG_HALTED          0x0001  // boot process is halted
 171 #define EPL_NMTMNU_FLAG_APP_INFORMED    0x0002  // application was informed about possible NMT state change
 172
 173 // return pointer to node info structure for specified node ID
 174 // d.k. may be replaced by special (hash) function if node ID array is smaller than 254
 175 #define EPL_NMTMNU_GET_NODEINFO(uiNodeId_p) (&EplNmtMnuInstance_g.m_aNodeInfo[uiNodeId_p - 1])
 176
 177 //---------------------------------------------------------------------------
 178 // local types
 179 //---------------------------------------------------------------------------
 180
 181 typedef enum {
 182         kEplNmtMnuIntNodeEventNoIdentResponse = 0x00,
 183         kEplNmtMnuIntNodeEventIdentResponse = 0x01,
 184         kEplNmtMnuIntNodeEventBoot = 0x02,
 185         kEplNmtMnuIntNodeEventExecReset = 0x03,
 186         kEplNmtMnuIntNodeEventConfigured = 0x04,
 187         kEplNmtMnuIntNodeEventNoStatusResponse = 0x05,
 188         kEplNmtMnuIntNodeEventStatusResponse = 0x06,
 189         kEplNmtMnuIntNodeEventHeartbeat = 0x07,
 190         kEplNmtMnuIntNodeEventNmtCmdSent = 0x08,
 191         kEplNmtMnuIntNodeEventTimerIdentReq = 0x09,
 192         kEplNmtMnuIntNodeEventTimerStatReq = 0x0A,
 193         kEplNmtMnuIntNodeEventTimerStateMon = 0x0B,
 194         kEplNmtMnuIntNodeEventTimerLonger = 0x0C,
 195         kEplNmtMnuIntNodeEventError = 0x0D,
 196
 197 } tEplNmtMnuIntNodeEvent;
 198
 199 typedef enum {
 200         kEplNmtMnuNodeStateUnknown = 0x00,
 201         kEplNmtMnuNodeStateIdentified = 0x01,
 202         kEplNmtMnuNodeStateResetConf = 0x02,    // CN reset after configuration update
 203         kEplNmtMnuNodeStateConfigured = 0x03,   // BootStep1 completed
 204         kEplNmtMnuNodeStateReadyToOp = 0x04,    // BootStep2 completed
 205         kEplNmtMnuNodeStateComChecked = 0x05,   // Communication checked successfully
 206         kEplNmtMnuNodeStateOperational = 0x06,  // CN is in NMT state OPERATIONAL
 207
 208 } tEplNmtMnuNodeState;
 209
 210 typedef struct {
 211         tEplTimerHdl m_TimerHdlStatReq; // timer to delay StatusRequests and IdentRequests
 212         tEplTimerHdl m_TimerHdlLonger;  // 2nd timer for NMT command EnableReadyToOp and CheckCommunication
 213         tEplNmtMnuNodeState m_NodeState;        // internal node state (kind of sub state of NMT state)
 214         u32 m_dwNodeCfg;        // subindex from 0x1F81
 215         u16 m_wFlags;           // flags: CN is being accessed isochronously
 216
 217 } tEplNmtMnuNodeInfo;
 218
 219 typedef struct {
 220         tEplNmtMnuNodeInfo m_aNodeInfo[EPL_NMT_MAX_NODE_ID];
 221         tEplTimerHdl m_TimerHdlNmtState;        // timeout for stay in NMT state
 222         unsigned int m_uiMandatorySlaveCount;
 223         unsigned int m_uiSignalSlaveCount;
 224         unsigned long m_ulStatusRequestDelay;   // in [ms] (object 0x1006 * EPL_C_NMT_STATREQ_CYCLE)
 225         unsigned long m_ulTimeoutReadyToOp;     // in [ms] (object 0x1F89/5)
 226         unsigned long m_ulTimeoutCheckCom;      // in [ms] (object 0x1006 * MultiplexedCycleCount)
 227         u16 m_wFlags;           // global flags
 228         u32 m_dwNmtStartup;     // object 0x1F80 NMT_StartUp_U32
 229         tEplNmtMnuCbNodeEvent m_pfnCbNodeEvent;
 230         tEplNmtMnuCbBootEvent m_pfnCbBootEvent;
 231
 232 } tEplNmtMnuInstance;
 233
 234 //---------------------------------------------------------------------------
 235 // local vars
 236 //---------------------------------------------------------------------------
 237
 238 static tEplNmtMnuInstance EplNmtMnuInstance_g;
 239
 240 //---------------------------------------------------------------------------
 241 // local function prototypes
 242 //---------------------------------------------------------------------------
 243
 244 static tEplKernel EplNmtMnuCbNmtRequest(tEplFrameInfo *pFrameInfo_p);
 245
 246 static tEplKernel EplNmtMnuCbIdentResponse(unsigned int uiNodeId_p,
 247                                            tEplIdentResponse *pIdentResponse_p);
 248
 249 static tEplKernel EplNmtMnuCbStatusResponse(unsigned int uiNodeId_p,
 250                                             tEplStatusResponse *pStatusResponse_p);
 251
 252 static tEplKernel EplNmtMnuCheckNmtState(unsigned int uiNodeId_p,
 253                                          tEplNmtMnuNodeInfo * pNodeInfo_p,
 254                                          tEplNmtState NodeNmtState_p,
 255                                          u16 wErrorCode_p,
 256                                          tEplNmtState LocalNmtState_p);
 257
 258 static tEplKernel EplNmtMnuStartBootStep1(void);
 259
 260 static tEplKernel EplNmtMnuStartBootStep2(void);
 261
 262 static tEplKernel EplNmtMnuStartCheckCom(void);
 263
 264 static tEplKernel EplNmtMnuNodeBootStep2(unsigned int uiNodeId_p,
 265                                          tEplNmtMnuNodeInfo * pNodeInfo_p);
 266
 267 static tEplKernel EplNmtMnuNodeCheckCom(unsigned int uiNodeId_p,
 268                                         tEplNmtMnuNodeInfo * pNodeInfo_p);
 269
 270 static tEplKernel EplNmtMnuStartNodes(void);
 271
 272 static tEplKernel EplNmtMnuProcessInternalEvent(unsigned int uiNodeId_p,
 273                                                 tEplNmtState NodeNmtState_p,
 274                                                 u16 wErrorCode_p,
 275                                                 tEplNmtMnuIntNodeEvent
 276                                                 NodeEvent_p);
 277
 278 static tEplKernel EplNmtMnuReset(void);
 279
 280 //=========================================================================//
 281 //                                                                         //
 282 //          P U B L I C   F U N C T I O N S                                //
 283 //                                                                         //
 284 //=========================================================================//
 285
 286 //---------------------------------------------------------------------------
 287 //
 288 // Function:    EplNmtMnuInit
 289 //
 290 // Description: init first instance of the module
 291 //
 292 //
 293 //
 294 // Parameters:
 295 //
 296 //
 297 // Returns:     tEplKernel  = errorcode
 298 //
 299 //
 300 // State:
 301 //
 302 //---------------------------------------------------------------------------
 303
 304 tEplKernel EplNmtMnuInit(tEplNmtMnuCbNodeEvent pfnCbNodeEvent_p,
 305                          tEplNmtMnuCbBootEvent pfnCbBootEvent_p)
 306 {
 307         tEplKernel Ret;
 308
 309         Ret = EplNmtMnuAddInstance(pfnCbNodeEvent_p, pfnCbBootEvent_p);
 310
 311         return Ret;
 312 }
 313
 314 //---------------------------------------------------------------------------
 315 //
 316 // Function:    EplNmtMnuAddInstance
 317 //
 318 // Description: init other instances of the module
 319 //
 320 //
 321 //
 322 // Parameters:
 323 //
 324 //
 325 // Returns:     tEplKernel  = errorcode
 326 //
 327 //
 328 // State:
 329 //
 330 //---------------------------------------------------------------------------
 331
 332 tEplKernel EplNmtMnuAddInstance(tEplNmtMnuCbNodeEvent pfnCbNodeEvent_p,
 333                                 tEplNmtMnuCbBootEvent pfnCbBootEvent_p)
 334 {
 335         tEplKernel Ret;
 336
 337         Ret = kEplSuccessful;
 338
 339         // reset instance structure
 340         EPL_MEMSET(&EplNmtMnuInstance_g, 0, sizeof(EplNmtMnuInstance_g));
 341
 342         if ((pfnCbNodeEvent_p == NULL) || (pfnCbBootEvent_p == NULL)) {
 343                 Ret = kEplNmtInvalidParam;
 344                 goto Exit;
 345         }
 346         EplNmtMnuInstance_g.m_pfnCbNodeEvent = pfnCbNodeEvent_p;
 347         EplNmtMnuInstance_g.m_pfnCbBootEvent = pfnCbBootEvent_p;
 348
 349         // initialize StatusRequest delay
 350         EplNmtMnuInstance_g.m_ulStatusRequestDelay = 5000L;
 351
 352         // register NmtMnResponse callback function
 353         Ret =
 354             EplDlluCalRegAsndService(kEplDllAsndNmtRequest,
 355                                      EplNmtMnuCbNmtRequest,
 356                                      kEplDllAsndFilterLocal);
 357
 358       Exit:
 359         return Ret;
 360
 361 }
 362
 363 //---------------------------------------------------------------------------
 364 //
 365 // Function:    EplNmtMnuDelInstance
 366 //
 367 // Description: delete instance
 368 //
 369 //
 370 //
 371 // Parameters:
 372 //
 373 //
 374 // Returns:     tEplKernel  = errorcode
 375 //
 376 //
 377 // State:
 378 //
 379 //---------------------------------------------------------------------------
 380
 381 tEplKernel EplNmtMnuDelInstance(void)
 382 {
 383         tEplKernel Ret;
 384
 385         Ret = kEplSuccessful;
 386
 387         // deregister NmtMnResponse callback function
 388         Ret =
 389             EplDlluCalRegAsndService(kEplDllAsndNmtRequest, NULL,
 390                                      kEplDllAsndFilterNone);
 391
 392         Ret = EplNmtMnuReset();
 393
 394         return Ret;
 395
 396 }
 397
 398 //---------------------------------------------------------------------------
 399 //
 400 // Function:    EplNmtMnuSendNmtCommandEx
 401 //
 402 // Description: sends the specified NMT command to the specified node.
 403 //
 404 // Parameters:  uiNodeId_p              = node ID to which the NMT command will be sent
 405 //              NmtCommand_p            = NMT command
 406 //
 407 // Returns:     tEplKernel              = error code
 408 //
 409 // State:
 410 //
 411 //---------------------------------------------------------------------------
 412
 413 tEplKernel EplNmtMnuSendNmtCommandEx(unsigned int uiNodeId_p,
 414                                      tEplNmtCommand NmtCommand_p,
 415                                      void *pNmtCommandData_p,
 416                                      unsigned int uiDataSize_p)
 417 {
 418         tEplKernel Ret = kEplSuccessful;
 419         tEplFrameInfo FrameInfo;
 420         u8 abBuffer[EPL_C_DLL_MINSIZE_NMTCMDEXT];
 421         tEplFrame *pFrame = (tEplFrame *) abBuffer;
 422         BOOL fSoftDeleteNode = FALSE;
 423
 424         if ((uiNodeId_p == 0) || (uiNodeId_p > EPL_C_ADR_BROADCAST)) {  // invalid node ID specified
 425                 Ret = kEplInvalidNodeId;
 426                 goto Exit;
 427         }
 428
 429         if ((pNmtCommandData_p != NULL)
 430             && (uiDataSize_p >
 431                 (EPL_C_DLL_MINSIZE_NMTCMDEXT - EPL_C_DLL_MINSIZE_NMTCMD))) {
 432                 Ret = kEplNmtInvalidParam;
 433                 goto Exit;
 434         }
 435         // $$$ d.k. may be check in future versions if the caller wants to perform prohibited state transitions
 436         //     the CN should not perform these transitions, but the expected NMT state will be changed and never fullfilled.
 437
 438         // build frame
 439         EPL_MEMSET(pFrame, 0x00, sizeof(abBuffer));
 440         AmiSetByteToLe(&pFrame->m_le_bDstNodeId, (u8) uiNodeId_p);
 441         AmiSetByteToLe(&pFrame->m_Data.m_Asnd.m_le_bServiceId,
 442                        (u8) kEplDllAsndNmtCommand);
 443         AmiSetByteToLe(&pFrame->m_Data.m_Asnd.m_Payload.m_NmtCommandService.
 444                        m_le_bNmtCommandId, (u8) NmtCommand_p);
 445         if ((pNmtCommandData_p != NULL) && (uiDataSize_p > 0)) {        // copy command data to frame
 446                 EPL_MEMCPY(&pFrame->m_Data.m_Asnd.m_Payload.m_NmtCommandService.
 447                            m_le_abNmtCommandData[0], pNmtCommandData_p,
 448                            uiDataSize_p);
 449         }
 450         // build info structure
 451         FrameInfo.m_NetTime.m_dwNanoSec = 0;
 452         FrameInfo.m_NetTime.m_dwSec = 0;
 453         FrameInfo.m_pFrame = pFrame;
 454         FrameInfo.m_uiFrameSize = sizeof(abBuffer);
 455
 456         // send NMT-Request
 457 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLU)) != 0)
 458         Ret = EplDlluCalAsyncSend(&FrameInfo,   // pointer to frameinfo
 459                                   kEplDllAsyncReqPrioNmt);      // priority
 460 #endif
 461         if (Ret != kEplSuccessful) {
 462                 goto Exit;
 463         }
 464
 465         EPL_DBGLVL_NMTMN_TRACE2("NMTCmd(%02X->%02X)\n", NmtCommand_p,
 466                                 uiNodeId_p);
 467
 468         switch (NmtCommand_p) {
 469         case kEplNmtCmdStartNode:
 470         case kEplNmtCmdEnterPreOperational2:
 471         case kEplNmtCmdEnableReadyToOperate:
 472                 {
 473                         // nothing left to do,
 474                         // because any further processing is done
 475                         // when the NMT command is actually sent
 476                         goto Exit;
 477                 }
 478
 479         case kEplNmtCmdStopNode:
 480                 {
 481                         fSoftDeleteNode = TRUE;
 482                         break;
 483                 }
 484
 485         case kEplNmtCmdResetNode:
 486         case kEplNmtCmdResetCommunication:
 487         case kEplNmtCmdResetConfiguration:
 488         case kEplNmtCmdSwReset:
 489                 {
 490                         break;
 491                 }
 492
 493         default:
 494                 goto Exit;
 495         }
 496
 497         // remove CN from isochronous phase;
 498         // This must be done here and not when NMT command is actually sent
 499         // because it will be too late and may cause unwanted errors
 500         if (uiNodeId_p != EPL_C_ADR_BROADCAST) {
 501                 if (fSoftDeleteNode == FALSE) { // remove CN immediately from isochronous phase
 502                         Ret = EplDlluCalDeleteNode(uiNodeId_p);
 503                 } else {        // remove CN from isochronous phase softly
 504                         Ret = EplDlluCalSoftDeleteNode(uiNodeId_p);
 505                 }
 506         } else {                // do it for all active CNs
 507                 for (uiNodeId_p = 1;
 508                      uiNodeId_p <= tabentries(EplNmtMnuInstance_g.m_aNodeInfo);
 509                      uiNodeId_p++) {
 510                         if ((EPL_NMTMNU_GET_NODEINFO(uiNodeId_p)->
 511                              m_dwNodeCfg & (EPL_NODEASSIGN_NODE_IS_CN |
 512                                             EPL_NODEASSIGN_NODE_EXISTS)) != 0) {
 513                                 if (fSoftDeleteNode == FALSE) { // remove CN immediately from isochronous phase
 514                                         Ret = EplDlluCalDeleteNode(uiNodeId_p);
 515                                 } else {        // remove CN from isochronous phase softly
 516                                         Ret =
 517                                             EplDlluCalSoftDeleteNode
 518                                             (uiNodeId_p);
 519                                 }
 520                         }
 521                 }
 522         }
 523
 524       Exit:
 525         return Ret;
 526 }
 527
 528 //---------------------------------------------------------------------------
 529 //
 530 // Function:    EplNmtMnuSendNmtCommand
 531 //
 532 // Description: sends the specified NMT command to the specified node.
 533 //
 534 // Parameters:  uiNodeId_p              = node ID to which the NMT command will be sent
 535 //              NmtCommand_p            = NMT command
 536 //
 537 // Returns:     tEplKernel              = error code
 538 //
 539 // State:
 540 //
 541 //---------------------------------------------------------------------------
 542
 543 tEplKernel EplNmtMnuSendNmtCommand(unsigned int uiNodeId_p,
 544                                    tEplNmtCommand NmtCommand_p)
 545 {
 546         tEplKernel Ret = kEplSuccessful;
 547
 548         Ret = EplNmtMnuSendNmtCommandEx(uiNodeId_p, NmtCommand_p, NULL, 0);
 549
 550 //Exit:
 551         return Ret;
 552 }
 553
 554 //---------------------------------------------------------------------------
 555 //
 556 // Function:    EplNmtMnuTriggerStateChange
 557 //
 558 // Description: triggers the specified node command for the specified node.
 559 //
 560 // Parameters:  uiNodeId_p              = node ID for which the node command will be executed
 561 //              NodeCommand_p           = node command
 562 //
 563 // Returns:     tEplKernel              = error code
 564 //
 565 // State:
 566 //
 567 //---------------------------------------------------------------------------
 568
 569 tEplKernel EplNmtMnuTriggerStateChange(unsigned int uiNodeId_p,
 570                                        tEplNmtNodeCommand NodeCommand_p)
 571 {
 572         tEplKernel Ret = kEplSuccessful;
 573         tEplNmtMnuIntNodeEvent NodeEvent;
 574         tEplObdSize ObdSize;
 575         u8 bNmtState;
 576         u16 wErrorCode = EPL_E_NO_ERROR;
 577
 578         if ((uiNodeId_p == 0) || (uiNodeId_p >= EPL_C_ADR_BROADCAST)) {
 579                 Ret = kEplInvalidNodeId;
 580                 goto Exit;
 581         }
 582
 583         switch (NodeCommand_p) {
 584         case kEplNmtNodeCommandBoot:
 585                 {
 586                         NodeEvent = kEplNmtMnuIntNodeEventBoot;
 587                         break;
 588                 }
 589
 590         case kEplNmtNodeCommandConfOk:
 591                 {
 592                         NodeEvent = kEplNmtMnuIntNodeEventConfigured;
 593                         break;
 594                 }
 595
 596         case kEplNmtNodeCommandConfErr:
 597                 {
 598                         NodeEvent = kEplNmtMnuIntNodeEventError;
 599                         wErrorCode = EPL_E_NMT_BPO1_CF_VERIFY;
 600                         break;
 601                 }
 602
 603         case kEplNmtNodeCommandConfReset:
 604                 {
 605                         NodeEvent = kEplNmtMnuIntNodeEventExecReset;
 606                         break;
 607                 }
 608
 609         default:
 610                 {               // invalid node command
 611                         goto Exit;
 612                 }
 613         }
 614
 615         // fetch current NMT state
 616         ObdSize = 1;
 617         Ret = EplObduReadEntry(0x1F8E, uiNodeId_p, &bNmtState, &ObdSize);
 618         if (Ret != kEplSuccessful) {
 619                 goto Exit;
 620         }
 621
 622         Ret = EplNmtMnuProcessInternalEvent(uiNodeId_p,
 623                                             (tEplNmtState) (bNmtState |
 624                                                             EPL_NMT_TYPE_CS),
 625                                             wErrorCode, NodeEvent);
 626
 627       Exit:
 628         return Ret;
 629 }
 630
 631 //---------------------------------------------------------------------------
 632 //
 633 // Function:    EplNmtMnuCbNmtStateChange
 634 //
 635 // Description: callback function for NMT state changes
 636 //
 637 // Parameters:  NmtStateChange_p        = NMT state change event
 638 //
 639 // Returns:     tEplKernel              = error code
 640 //
 641 //
 642 // State:
 643 //
 644 //---------------------------------------------------------------------------
 645
 646 tEplKernel EplNmtMnuCbNmtStateChange(tEplEventNmtStateChange NmtStateChange_p)
 647 {
 648         tEplKernel Ret = kEplSuccessful;
 649
 650         // do work which must be done in that state
 651         switch (NmtStateChange_p.m_NewNmtState) {
 652                 // EPL stack is not running
 653 /*        case kEplNmtGsOff:
 654             break;
 655
 656         // first init of the hardware
 657         case kEplNmtGsInitialising:
 658             break;
 659
 660         // init of the manufacturer-specific profile area and the
 661         // standardised device profile area
 662         case kEplNmtGsResetApplication:
 663         {
 664             break;
 665         }
 666
 667         // init of the communication profile area
 668         case kEplNmtGsResetCommunication:
 669         {
 670             break;
 671         }
 672 */
 673                 // build the configuration with infos from OD
 674         case kEplNmtGsResetConfiguration:
 675                 {
 676                         u32 dwTimeout;
 677                         tEplObdSize ObdSize;
 678
 679                         // read object 0x1F80 NMT_StartUp_U32
 680                         ObdSize = 4;
 681                         Ret =
 682                             EplObduReadEntry(0x1F80, 0,
 683                                              &EplNmtMnuInstance_g.
 684                                              m_dwNmtStartup, &ObdSize);
 685                         if (Ret != kEplSuccessful) {
 686                                 break;
 687                         }
 688                         // compute StatusReqDelay = object 0x1006 * EPL_C_NMT_STATREQ_CYCLE
 689                         ObdSize = sizeof(dwTimeout);
 690                         Ret = EplObduReadEntry(0x1006, 0, &dwTimeout, &ObdSize);
 691                         if (Ret != kEplSuccessful) {
 692                                 break;
 693                         }
 694                         if (dwTimeout != 0L) {
 695                                 EplNmtMnuInstance_g.m_ulStatusRequestDelay =
 696                                     dwTimeout * EPL_C_NMT_STATREQ_CYCLE / 1000L;
 697                                 if (EplNmtMnuInstance_g.
 698                                     m_ulStatusRequestDelay == 0L) {
 699                                         EplNmtMnuInstance_g.m_ulStatusRequestDelay = 1L;        // at least 1 ms
 700                                 }
 701                                 // $$$ fetch and use MultiplexedCycleCount from OD
 702                                 EplNmtMnuInstance_g.m_ulTimeoutCheckCom =
 703                                     dwTimeout * EPL_C_NMT_STATREQ_CYCLE / 1000L;
 704                                 if (EplNmtMnuInstance_g.m_ulTimeoutCheckCom ==
 705                                     0L) {
 706                                         EplNmtMnuInstance_g.m_ulTimeoutCheckCom = 1L;   // at least 1 ms
 707                                 }
 708                         }
 709                         // fetch ReadyToOp Timeout from OD
 710                         ObdSize = sizeof(dwTimeout);
 711                         Ret = EplObduReadEntry(0x1F89, 5, &dwTimeout, &ObdSize);
 712                         if (Ret != kEplSuccessful) {
 713                                 break;
 714                         }
 715                         if (dwTimeout != 0L) {
 716                                 // convert [us] to [ms]
 717                                 dwTimeout /= 1000L;
 718                                 if (dwTimeout == 0L) {
 719                                         dwTimeout = 1L; // at least 1 ms
 720                                 }
 721                                 EplNmtMnuInstance_g.m_ulTimeoutReadyToOp =
 722                                     dwTimeout;
 723                         } else {
 724                                 EplNmtMnuInstance_g.m_ulTimeoutReadyToOp = 0L;
 725                         }
 726                         break;
 727                 }
 728 /*
 729         //-----------------------------------------------------------
 730         // CN part of the state machine
 731
 732         // node liste for EPL-Frames and check timeout
 733         case kEplNmtCsNotActive:
 734         {
 735             break;
 736         }
 737
 738         // node process only async frames
 739         case kEplNmtCsPreOperational1:
 740         {
 741             break;
 742         }
 743
 744         // node process isochronus and asynchronus frames
 745         case kEplNmtCsPreOperational2:
 746         {
 747             break;
 748         }
 749
 750         // node should be configured und application is ready
 751         case kEplNmtCsReadyToOperate:
 752         {
 753             break;
 754         }
 755
 756         // normal work state
 757         case kEplNmtCsOperational:
 758         {
 759             break;
 760         }
 761
 762         // node stopped by MN
 763         // -> only process asynchronus frames
 764         case kEplNmtCsStopped:
 765         {
 766             break;
 767         }
 768
 769         // no EPL cycle
 770         // -> normal ethernet communication
 771         case kEplNmtCsBasicEthernet:
 772         {
 773             break;
 774         }
 775 */
 776                 //-----------------------------------------------------------
 777                 // MN part of the state machine
 778
 779                 // node listens for EPL-Frames and check timeout
 780         case kEplNmtMsNotActive:
 781                 {
 782                         break;
 783                 }
 784
 785                 // node processes only async frames
 786         case kEplNmtMsPreOperational1:
 787                 {
 788                         u32 dwTimeout;
 789                         tEplTimerArg TimerArg;
 790                         tEplObdSize ObdSize;
 791                         tEplEvent Event;
 792
 793                         // clear global flags, e.g. reenable boot process
 794                         EplNmtMnuInstance_g.m_wFlags = 0;
 795
 796                         // reset IdentResponses and running IdentRequests and StatusRequests
 797                         Ret = EplIdentuReset();
 798                         Ret = EplStatusuReset();
 799
 800                         // reset timers
 801                         Ret = EplNmtMnuReset();
 802
 803                         // 2008/11/18 d.k. reset internal node info is not necessary,
 804                         //                 because timer flags are important and other
 805                         //                 things are reset by EplNmtMnuStartBootStep1().
 806 /*
 807             EPL_MEMSET(EplNmtMnuInstance_g.m_aNodeInfo,
 808                        0,
 809                        sizeof (EplNmtMnuInstance_g.m_aNodeInfo));
 810 */
 811
 812                         // inform DLL about NMT state change,
 813                         // so that it can clear the asynchonous queues and start the reduced cycle
 814                         Event.m_EventSink = kEplEventSinkDllk;
 815                         Event.m_EventType = kEplEventTypeDllkStartReducedCycle;
 816                         EPL_MEMSET(&Event.m_NetTime, 0x00,
 817                                    sizeof(Event.m_NetTime));
 818                         Event.m_pArg = NULL;
 819                         Event.m_uiSize = 0;
 820                         Ret = EplEventuPost(&Event);
 821                         if (Ret != kEplSuccessful) {
 822                                 break;
 823                         }
 824                         // reset all nodes
 825                         // d.k.: skip this step if was just done before, e.g. because of a ResetNode command from a diagnostic node
 826                         if (NmtStateChange_p.m_NmtEvent ==
 827                             kEplNmtEventTimerMsPreOp1) {
 828                                 BENCHMARK_MOD_07_TOGGLE(9);
 829
 830                                 EPL_NMTMNU_DBG_POST_TRACE_VALUE(0,
 831                                                                 EPL_C_ADR_BROADCAST,
 832                                                                 kEplNmtCmdResetNode);
 833
 834                                 Ret =
 835                                     EplNmtMnuSendNmtCommand(EPL_C_ADR_BROADCAST,
 836                                                             kEplNmtCmdResetNode);
 837                                 if (Ret != kEplSuccessful) {
 838                                         break;
 839                                 }
 840                         }
 841                         // start network scan
 842                         Ret = EplNmtMnuStartBootStep1();
 843
 844                         // start timer for 0x1F89/2 MNTimeoutPreOp1_U32
 845                         ObdSize = sizeof(dwTimeout);
 846                         Ret = EplObduReadEntry(0x1F89, 2, &dwTimeout, &ObdSize);
 847                         if (Ret != kEplSuccessful) {
 848                                 break;
 849                         }
 850                         if (dwTimeout != 0L) {
 851                                 dwTimeout /= 1000L;
 852                                 if (dwTimeout == 0L) {
 853                                         dwTimeout = 1L; // at least 1 ms
 854                                 }
 855                                 TimerArg.m_EventSink = kEplEventSinkNmtMnu;
 856                                 TimerArg.m_ulArg = 0;
 857                                 Ret =
 858                                     EplTimeruModifyTimerMs(&EplNmtMnuInstance_g.
 859                                                            m_TimerHdlNmtState,
 860                                                            dwTimeout, TimerArg);
 861                         }
 862                         break;
 863                 }
 864
 865                 // node processes isochronous and asynchronous frames
 866         case kEplNmtMsPreOperational2:
 867                 {
 868                         // add identified CNs to isochronous phase
 869                         // send EnableReadyToOp to all identified CNs
 870                         Ret = EplNmtMnuStartBootStep2();
 871
 872                         // wait for NMT state change of CNs
 873                         break;
 874                 }
 875
 876                 // node should be configured und application is ready
 877         case kEplNmtMsReadyToOperate:
 878                 {
 879                         // check if PRes of CNs are OK
 880                         // d.k. that means wait CycleLength * MultiplexCycleCount (i.e. start timer)
 881                         //      because Dllk checks PRes of CNs automatically in ReadyToOp
 882                         Ret = EplNmtMnuStartCheckCom();
 883                         break;
 884                 }
 885
 886                 // normal work state
 887         case kEplNmtMsOperational:
 888                 {
 889                         // send StartNode to CNs
 890                         // wait for NMT state change of CNs
 891                         Ret = EplNmtMnuStartNodes();
 892                         break;
 893                 }
 894
 895                 // no EPL cycle
 896                 // -> normal ethernet communication
 897         case kEplNmtMsBasicEthernet:
 898                 {
 899                         break;
 900                 }
 901
 902         default:
 903                 {
 904 //            TRACE0("EplNmtMnuCbNmtStateChange(): unhandled NMT state\n");
 905                 }
 906         }
 907
 908         return Ret;
 909 }
 910
 911 //---------------------------------------------------------------------------
 912 //
 913 // Function:    EplNmtMnuCbCheckEvent
 914 //
 915 // Description: callback funktion for NMT events before they are actually executed.
 916 //              The EPL API layer must forward NMT events from NmtCnu module.
 917 //              This module will reject some NMT commands while MN.
 918 //
 919 // Parameters:  NmtEvent_p              = outstanding NMT event for approval
 920 //
 921 // Returns:     tEplKernel              = error code
 922 //                      kEplReject      = reject the NMT event
 923 //
 924 // State:
 925 //
 926 //---------------------------------------------------------------------------
 927
 928 tEplKernel EplNmtMnuCbCheckEvent(tEplNmtEvent NmtEvent_p)
 929 {
 930         tEplKernel Ret = kEplSuccessful;
 931
 932         return Ret;
 933 }
 934
 935 //---------------------------------------------------------------------------
 936 //
 937 // Function:    EplNmtuProcessEvent
 938 //
 939 // Description: processes events from event queue
 940 //
 941 // Parameters:  pEvent_p        = pointer to event
 942 //
 943 // Returns:     tEplKernel      = errorcode
 944 //
 945 // State:
 946 //
 947 //---------------------------------------------------------------------------
 948
 949 tEplKernel EplNmtMnuProcessEvent(tEplEvent *pEvent_p)
 950 {
 951         tEplKernel Ret;
 952
 953         Ret = kEplSuccessful;
 954
 955         // process event
 956         switch (pEvent_p->m_EventType) {
 957                 // timer event
 958         case kEplEventTypeTimer:
 959                 {
 960                         tEplTimerEventArg *pTimerEventArg =
 961                             (tEplTimerEventArg *) pEvent_p->m_pArg;
 962                         unsigned int uiNodeId;
 963
 964                         uiNodeId =
 965                             (unsigned int)(pTimerEventArg->
 966                                            m_ulArg &
 967                                            EPL_NMTMNU_TIMERARG_NODE_MASK);
 968                         if (uiNodeId != 0) {
 969                                 tEplObdSize ObdSize;
 970                                 u8 bNmtState;
 971                                 tEplNmtMnuNodeInfo *pNodeInfo;
 972
 973                                 pNodeInfo = EPL_NMTMNU_GET_NODEINFO(uiNodeId);
 974
 975                                 ObdSize = 1;
 976                                 Ret =
 977                                     EplObduReadEntry(0x1F8E, uiNodeId,
 978                                                      &bNmtState, &ObdSize);
 979                                 if (Ret != kEplSuccessful) {
 980                                         break;
 981                                 }
 982
 983                                 if ((pTimerEventArg->
 984                                      m_ulArg & EPL_NMTMNU_TIMERARG_IDENTREQ) !=
 985                                     0L) {
 986                                         if ((pNodeInfo->
 987                                              m_wFlags &
 988                                              EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ)
 989                                             != (pTimerEventArg->m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_SR)) {      // this is an old (already deleted or modified) timer
 990                                                 // but not the current timer
 991                                                 // so discard it
 992                                                 EPL_NMTMNU_DBG_POST_TRACE_VALUE
 993                                                     (kEplNmtMnuIntNodeEventTimerIdentReq,
 994                                                      uiNodeId,
 995                                                      ((pNodeInfo->
 996                                                        m_NodeState << 8)
 997                                                       | 0xFF));
 998
 999                                                 break;
1000                                         }
1001 /*
1002                     EPL_NMTMNU_DBG_POST_TRACE_VALUE(kEplNmtMnuIntNodeEventTimerIdentReq,
1003                                                     uiNodeId,
1004                                                     ((pNodeInfo->m_NodeState << 8)
1005                                                      | 0x80
1006                                                      | ((pNodeInfo->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ) >> 6)
1007                                                      | ((pTimerEventArg->m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_SR) >> 8)));
1008 */
1009                                         Ret =
1010                                             EplNmtMnuProcessInternalEvent
1011                                             (uiNodeId,
1012                                              (tEplNmtState) (bNmtState |
1013                                                              EPL_NMT_TYPE_CS),
1014                                              EPL_E_NO_ERROR,
1015                                              kEplNmtMnuIntNodeEventTimerIdentReq);
1016                                 }
1017
1018                                 else if ((pTimerEventArg->
1019                                           m_ulArg & EPL_NMTMNU_TIMERARG_STATREQ)
1020                                          != 0L) {
1021                                         if ((pNodeInfo->
1022                                              m_wFlags &
1023                                              EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ)
1024                                             != (pTimerEventArg->m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_SR)) {      // this is an old (already deleted or modified) timer
1025                                                 // but not the current timer
1026                                                 // so discard it
1027                                                 EPL_NMTMNU_DBG_POST_TRACE_VALUE
1028                                                     (kEplNmtMnuIntNodeEventTimerStatReq,
1029                                                      uiNodeId,
1030                                                      ((pNodeInfo->
1031                                                        m_NodeState << 8)
1032                                                       | 0xFF));
1033
1034                                                 break;
1035                                         }
1036 /*
1037                     EPL_NMTMNU_DBG_POST_TRACE_VALUE(kEplNmtMnuIntNodeEventTimerStatReq,
1038                                                     uiNodeId,
1039                                                     ((pNodeInfo->m_NodeState << 8)
1040                                                      | 0x80
1041                                                      | ((pNodeInfo->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ) >> 6)
1042                                                      | ((pTimerEventArg->m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_SR) >> 8)));
1043 */
1044                                         Ret =
1045                                             EplNmtMnuProcessInternalEvent
1046                                             (uiNodeId,
1047                                              (tEplNmtState) (bNmtState |
1048                                                              EPL_NMT_TYPE_CS),
1049                                              EPL_E_NO_ERROR,
1050                                              kEplNmtMnuIntNodeEventTimerStatReq);
1051                                 }
1052
1053                                 else if ((pTimerEventArg->
1054                                           m_ulArg &
1055                                           EPL_NMTMNU_TIMERARG_STATE_MON) !=
1056                                          0L) {
1057                                         if ((pNodeInfo->
1058                                              m_wFlags &
1059                                              EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ)
1060                                             != (pTimerEventArg->m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_SR)) {      // this is an old (already deleted or modified) timer
1061                                                 // but not the current timer
1062                                                 // so discard it
1063                                                 EPL_NMTMNU_DBG_POST_TRACE_VALUE
1064                                                     (kEplNmtMnuIntNodeEventTimerStateMon,
1065                                                      uiNodeId,
1066                                                      ((pNodeInfo->
1067                                                        m_NodeState << 8)
1068                                                       | 0xFF));
1069
1070                                                 break;
1071                                         }
1072 /*
1073                     EPL_NMTMNU_DBG_POST_TRACE_VALUE(kEplNmtMnuIntNodeEventTimerStatReq,
1074                                                     uiNodeId,
1075                                                     ((pNodeInfo->m_NodeState << 8)
1076                                                      | 0x80
1077                                                      | ((pNodeInfo->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ) >> 6)
1078                                                      | ((pTimerEventArg->m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_SR) >> 8)));
1079 */
1080                                         Ret =
1081                                             EplNmtMnuProcessInternalEvent
1082                                             (uiNodeId,
1083                                              (tEplNmtState) (bNmtState |
1084                                                              EPL_NMT_TYPE_CS),
1085                                              EPL_E_NO_ERROR,
1086                                              kEplNmtMnuIntNodeEventTimerStateMon);
1087                                 }
1088
1089                                 else if ((pTimerEventArg->
1090                                           m_ulArg & EPL_NMTMNU_TIMERARG_LONGER)
1091                                          != 0L) {
1092                                         if ((pNodeInfo->
1093                                              m_wFlags &
1094                                              EPL_NMTMNU_NODE_FLAG_COUNT_LONGER)
1095                                             != (pTimerEventArg->m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_LO)) {      // this is an old (already deleted or modified) timer
1096                                                 // but not the current timer
1097                                                 // so discard it
1098                                                 EPL_NMTMNU_DBG_POST_TRACE_VALUE
1099                                                     (kEplNmtMnuIntNodeEventTimerLonger,
1100                                                      uiNodeId,
1101                                                      ((pNodeInfo->
1102                                                        m_NodeState << 8)
1103                                                       | 0xFF));
1104
1105                                                 break;
1106                                         }
1107 /*
1108                     EPL_NMTMNU_DBG_POST_TRACE_VALUE(kEplNmtMnuIntNodeEventTimerLonger,
1109                                                     uiNodeId,
1110                                                     ((pNodeInfo->m_NodeState << 8)
1111                                                      | 0x80
1112                                                      | ((pNodeInfo->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_LONGER) >> 6)
1113                                                      | ((pTimerEventArg->m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_LO) >> 8)));
1114 */
1115                                         Ret =
1116                                             EplNmtMnuProcessInternalEvent
1117                                             (uiNodeId,
1118                                              (tEplNmtState) (bNmtState |
1119                                                              EPL_NMT_TYPE_CS),
1120                                              EPL_E_NO_ERROR,
1121                                              kEplNmtMnuIntNodeEventTimerLonger);
1122                                 }
1123
1124                         } else {        // global timer event
1125                         }
1126                         break;
1127                 }
1128
1129         case kEplEventTypeHeartbeat:
1130                 {
1131                         tEplHeartbeatEvent *pHeartbeatEvent =
1132                             (tEplHeartbeatEvent *) pEvent_p->m_pArg;
1133
1134                         Ret =
1135                             EplNmtMnuProcessInternalEvent(pHeartbeatEvent->
1136                                                           m_uiNodeId,
1137                                                           pHeartbeatEvent->
1138                                                           m_NmtState,
1139                                                           pHeartbeatEvent->
1140                                                           m_wErrorCode,
1141                                                           kEplNmtMnuIntNodeEventHeartbeat);
1142                         break;
1143                 }
1144
1145         case kEplEventTypeNmtMnuNmtCmdSent:
1146                 {
1147                         tEplFrame *pFrame = (tEplFrame *) pEvent_p->m_pArg;
1148                         unsigned int uiNodeId;
1149                         tEplNmtCommand NmtCommand;
1150                         u8 bNmtState;
1151
1152                         uiNodeId = AmiGetByteFromLe(&pFrame->m_le_bDstNodeId);
1153                         NmtCommand =
1154                             (tEplNmtCommand) AmiGetByteFromLe(&pFrame->m_Data.
1155                                                               m_Asnd.m_Payload.
1156                                                               m_NmtCommandService.
1157                                                               m_le_bNmtCommandId);
1158
1159                         switch (NmtCommand) {
1160                         case kEplNmtCmdStartNode:
1161                                 bNmtState =
1162                                     (u8) (kEplNmtCsOperational & 0xFF);
1163                                 break;
1164
1165                         case kEplNmtCmdStopNode:
1166                                 bNmtState = (u8) (kEplNmtCsStopped & 0xFF);
1167                                 break;
1168
1169                         case kEplNmtCmdEnterPreOperational2:
1170                                 bNmtState =
1171                                     (u8) (kEplNmtCsPreOperational2 & 0xFF);
1172                                 break;
1173
1174                         case kEplNmtCmdEnableReadyToOperate:
1175                                 // d.k. do not change expected node state, because of DS 1.0.0 7.3.1.2.1 Plain NMT State Command
1176                                 //      and because node may not change NMT state within EPL_C_NMT_STATE_TOLERANCE
1177                                 bNmtState =
1178                                     (u8) (kEplNmtCsPreOperational2 & 0xFF);
1179                                 break;
1180
1181                         case kEplNmtCmdResetNode:
1182                         case kEplNmtCmdResetCommunication:
1183                         case kEplNmtCmdResetConfiguration:
1184                         case kEplNmtCmdSwReset:
1185                                 bNmtState = (u8) (kEplNmtCsNotActive & 0xFF);
1186                                 // EplNmtMnuProcessInternalEvent() sets internal node state to kEplNmtMnuNodeStateUnknown
1187                                 // after next unresponded IdentRequest/StatusRequest
1188                                 break;
1189
1190                         default:
1191                                 goto Exit;
1192                         }
1193
1194                         // process as internal event which update expected NMT state in OD
1195                         if (uiNodeId != EPL_C_ADR_BROADCAST) {
1196                                 Ret = EplNmtMnuProcessInternalEvent(uiNodeId,
1197                                                                     (tEplNmtState)
1198                                                                     (bNmtState |
1199                                                                      EPL_NMT_TYPE_CS),
1200                                                                     0,
1201                                                                     kEplNmtMnuIntNodeEventNmtCmdSent);
1202
1203                         } else {        // process internal event for all active nodes (except myself)
1204
1205                                 for (uiNodeId = 1;
1206                                      uiNodeId <=
1207                                      tabentries(EplNmtMnuInstance_g.
1208                                                 m_aNodeInfo); uiNodeId++) {
1209                                         if ((EPL_NMTMNU_GET_NODEINFO(uiNodeId)->
1210                                              m_dwNodeCfg &
1211                                              (EPL_NODEASSIGN_NODE_IS_CN |
1212                                               EPL_NODEASSIGN_NODE_EXISTS)) !=
1213                                             0) {
1214                                                 Ret =
1215                                                     EplNmtMnuProcessInternalEvent
1216                                                     (uiNodeId,
1217                                                      (tEplNmtState) (bNmtState |
1218                                                                      EPL_NMT_TYPE_CS),
1219                                                      0,
1220                                                      kEplNmtMnuIntNodeEventNmtCmdSent);
1221
1222                                                 if (Ret != kEplSuccessful) {
1223                                                         goto Exit;
1224                                                 }
1225                                         }
1226                                 }
1227                         }
1228
1229                         break;
1230                 }
1231
1232         default:
1233                 {
1234                         Ret = kEplNmtInvalidEvent;
1235                 }
1236
1237         }
1238
1239       Exit:
1240         return Ret;
1241 }
1242
1243 //---------------------------------------------------------------------------
1244 //
1245 // Function:    EplNmtMnuGetRunningTimerStatReq
1246 //
1247 // Description: returns a bit field with running StatReq timers
1248 //              just for debugging purposes
1249 //
1250 // Parameters:  (none)
1251 //
1252 // Returns:     tEplKernel              = error code
1253 //
1254 // State:
1255 //
1256 //---------------------------------------------------------------------------
1257
1258 tEplKernel EplNmtMnuGetDiagnosticInfo(unsigned int *puiMandatorySlaveCount_p,
1259                                       unsigned int *puiSignalSlaveCount_p,
1260                                       u16 *pwFlags_p)
1261 {
1262         tEplKernel Ret = kEplSuccessful;
1263
1264         if ((puiMandatorySlaveCount_p == NULL)
1265             || (puiSignalSlaveCount_p == NULL)
1266             || (pwFlags_p == NULL)) {
1267                 Ret = kEplNmtInvalidParam;
1268                 goto Exit;
1269         }
1270
1271         *puiMandatorySlaveCount_p = EplNmtMnuInstance_g.m_uiMandatorySlaveCount;
1272         *puiSignalSlaveCount_p = EplNmtMnuInstance_g.m_uiSignalSlaveCount;
1273         *pwFlags_p = EplNmtMnuInstance_g.m_wFlags;
1274
1275       Exit:
1276         return Ret;
1277 }
1278
1279 //---------------------------------------------------------------------------
1280 //
1281 // Function:    EplNmtMnuGetRunningTimerStatReq
1282 //
1283 // Description: returns a bit field with running StatReq timers
1284 //              just for debugging purposes
1285 //
1286 // Parameters:  (none)
1287 //
1288 // Returns:     tEplKernel              = error code
1289 //
1290 // State:
1291 //
1292 //---------------------------------------------------------------------------
1293 /*
1294 u32 EplNmtMnuGetRunningTimerStatReq(void)
1295 {
1296 tEplKernel      Ret = kEplSuccessful;
1297 unsigned int    uiIndex;
1298 tEplNmtMnuNodeInfo* pNodeInfo;
1299
1300     pNodeInfo = EplNmtMnuInstance_g.m_aNodeInfo;
1301     for (uiIndex = 1; uiIndex <= tabentries(EplNmtMnuInstance_g.m_aNodeInfo); uiIndex++, pNodeInfo++)
1302     {
1303         if (pNodeInfo->m_NodeState == kEplNmtMnuNodeStateConfigured)
1304         {
1305             // reset flag "scanned once"
1306             pNodeInfo->m_wFlags &= ~EPL_NMTMNU_NODE_FLAG_SCANNED;
1307
1308             Ret = EplNmtMnuNodeBootStep2(uiIndex, pNodeInfo);
1309             if (Ret != kEplSuccessful)
1310             {
1311                 goto Exit;
1312             }
1313             EplNmtMnuInstance_g.m_uiSignalSlaveCount++;
1314             // signal slave counter shall be decremented if StatusRequest was sent once to a CN
1315             // mandatory slave counter shall be decremented if mandatory CN is ReadyToOp
1316         }
1317     }
1318
1319 Exit:
1320     return Ret;
1321 }
1322 */
1323
1324 //=========================================================================//
1325 //                                                                         //
1326 //          P R I V A T E   F U N C T I O N S                              //
1327 //                                                                         //
1328 //=========================================================================//
1329
1330 //---------------------------------------------------------------------------
1331 //
1332 // Function:    EplNmtMnuCbNmtRequest
1333 //
1334 // Description: callback funktion for NmtRequest
1335 //
1336 // Parameters:  pFrameInfo_p            = Frame with the NmtRequest
1337 //
1338 // Returns:     tEplKernel              = error code
1339 //
1340 //
1341 // State:
1342 //
1343 //---------------------------------------------------------------------------
1344
1345 static tEplKernel EplNmtMnuCbNmtRequest(tEplFrameInfo *pFrameInfo_p)
1346 {
1347         tEplKernel Ret = kEplSuccessful;
1348
1349         // $$$ perform NMTRequest
1350         return Ret;
1351 }
1352
1353 //---------------------------------------------------------------------------
1354 //
1355 // Function:    EplNmtMnuCbIdentResponse
1356 //
1357 // Description: callback funktion for IdentResponse
1358 //
1359 // Parameters:  uiNodeId_p              = node ID for which IdentReponse was received
1360 //              pIdentResponse_p        = pointer to IdentResponse
1361 //                                        is NULL if node did not answer
1362 //
1363 // Returns:     tEplKernel              = error code
1364 //
1365 // State:
1366 //
1367 //---------------------------------------------------------------------------
1368
1369 static tEplKernel EplNmtMnuCbIdentResponse(unsigned int uiNodeId_p,
1370                                            tEplIdentResponse *pIdentResponse_p)
1371 {
1372         tEplKernel Ret = kEplSuccessful;
1373
1374         if (pIdentResponse_p == NULL) { // node did not answer
1375                 Ret = EplNmtMnuProcessInternalEvent(uiNodeId_p, kEplNmtCsNotActive, EPL_E_NMT_NO_IDENT_RES,     // was EPL_E_NO_ERROR
1376                                                     kEplNmtMnuIntNodeEventNoIdentResponse);
1377         } else {                // node answered IdentRequest
1378                 tEplObdSize ObdSize;
1379                 u32 dwDevType;
1380                 u16 wErrorCode = EPL_E_NO_ERROR;
1381                 tEplNmtState NmtState =
1382                     (tEplNmtState) (AmiGetByteFromLe
1383                                     (&pIdentResponse_p->
1384                                      m_le_bNmtStatus) | EPL_NMT_TYPE_CS);
1385
1386                 // check IdentResponse $$$ move to ProcessIntern, because this function may be called also if CN
1387
1388                 // check DeviceType (0x1F84)
1389                 ObdSize = 4;
1390                 Ret =
1391                     EplObduReadEntry(0x1F84, uiNodeId_p, &dwDevType, &ObdSize);
1392                 if (Ret != kEplSuccessful) {
1393                         goto Exit;
1394                 }
1395                 if (dwDevType != 0L) {  // actually compare it with DeviceType from IdentResponse
1396                         if (AmiGetDwordFromLe(&pIdentResponse_p->m_le_dwDeviceType) != dwDevType) {     // wrong DeviceType
1397                                 NmtState = kEplNmtCsNotActive;
1398                                 wErrorCode = EPL_E_NMT_BPO1_DEVICE_TYPE;
1399                         }
1400                 }
1401
1402                 Ret = EplNmtMnuProcessInternalEvent(uiNodeId_p,
1403                                                     NmtState,
1404                                                     wErrorCode,
1405                                                     kEplNmtMnuIntNodeEventIdentResponse);
1406         }
1407
1408       Exit:
1409         return Ret;
1410 }
1411
1412 //---------------------------------------------------------------------------
1413 //
1414 // Function:    EplNmtMnuCbStatusResponse
1415 //
1416 // Description: callback funktion for StatusResponse
1417 //
1418 // Parameters:  uiNodeId_p              = node ID for which IdentReponse was received
1419 //              pIdentResponse_p        = pointer to IdentResponse
1420 //                                        is NULL if node did not answer
1421 //
1422 // Returns:     tEplKernel              = error code
1423 //
1424 // State:
1425 //
1426 //---------------------------------------------------------------------------
1427
1428 static tEplKernel EplNmtMnuCbStatusResponse(unsigned int uiNodeId_p,
1429                                             tEplStatusResponse *pStatusResponse_p)
1430 {
1431         tEplKernel Ret = kEplSuccessful;
1432
1433         if (pStatusResponse_p == NULL) {        // node did not answer
1434                 Ret = EplNmtMnuProcessInternalEvent(uiNodeId_p, kEplNmtCsNotActive, EPL_E_NMT_NO_STATUS_RES,    // was EPL_E_NO_ERROR
1435                                                     kEplNmtMnuIntNodeEventNoStatusResponse);
1436         } else {                // node answered StatusRequest
1437                 Ret = EplNmtMnuProcessInternalEvent(uiNodeId_p,
1438                                                     (tEplNmtState)
1439                                                     (AmiGetByteFromLe
1440                                                      (&pStatusResponse_p->
1441                                                       m_le_bNmtStatus) |
1442                                                      EPL_NMT_TYPE_CS),
1443                                                     EPL_E_NO_ERROR,
1444                                                     kEplNmtMnuIntNodeEventStatusResponse);
1445         }
1446
1447         return Ret;
1448 }
1449
1450 //---------------------------------------------------------------------------
1451 //
1452 // Function:    EplNmtMnuStartBootStep1
1453 //
1454 // Description: starts BootStep1
1455 //
1456 // Parameters:  (none)
1457 //
1458 // Returns:     tEplKernel              = error code
1459 //
1460 // State:
1461 //
1462 //---------------------------------------------------------------------------
1463
1464 static tEplKernel EplNmtMnuStartBootStep1(void)
1465 {
1466         tEplKernel Ret = kEplSuccessful;
1467         unsigned int uiSubIndex;
1468         unsigned int uiLocalNodeId;
1469         u32 dwNodeCfg;
1470         tEplObdSize ObdSize;
1471
1472         // $$$ d.k.: save current time for 0x1F89/2 MNTimeoutPreOp1_U32
1473
1474         // start network scan
1475         EplNmtMnuInstance_g.m_uiMandatorySlaveCount = 0;
1476         EplNmtMnuInstance_g.m_uiSignalSlaveCount = 0;
1477         // check 0x1F81
1478         uiLocalNodeId = EplObduGetNodeId();
1479         for (uiSubIndex = 1; uiSubIndex <= 254; uiSubIndex++) {
1480                 ObdSize = 4;
1481                 Ret =
1482                     EplObduReadEntry(0x1F81, uiSubIndex, &dwNodeCfg, &ObdSize);
1483                 if (Ret != kEplSuccessful) {
1484                         goto Exit;
1485                 }
1486                 if (uiSubIndex != uiLocalNodeId) {
1487                         // reset flags "not scanned" and "isochronous"
1488                         EPL_NMTMNU_GET_NODEINFO(uiSubIndex)->m_wFlags &=
1489                             ~(EPL_NMTMNU_NODE_FLAG_ISOCHRON |
1490                               EPL_NMTMNU_NODE_FLAG_NOT_SCANNED);
1491
1492                         if (uiSubIndex == EPL_C_ADR_DIAG_DEF_NODE_ID) { // diagnostic node must be scanned by MN in any case
1493                                 dwNodeCfg |=
1494                                     (EPL_NODEASSIGN_NODE_IS_CN |
1495                                      EPL_NODEASSIGN_NODE_EXISTS);
1496                                 // and it must be isochronously accessed
1497                                 dwNodeCfg &= ~EPL_NODEASSIGN_ASYNCONLY_NODE;
1498                         }
1499                         // save node config in local node info structure
1500                         EPL_NMTMNU_GET_NODEINFO(uiSubIndex)->m_dwNodeCfg =
1501                             dwNodeCfg;
1502                         EPL_NMTMNU_GET_NODEINFO(uiSubIndex)->m_NodeState =
1503                             kEplNmtMnuNodeStateUnknown;
1504
1505                         if ((dwNodeCfg & (EPL_NODEASSIGN_NODE_IS_CN | EPL_NODEASSIGN_NODE_EXISTS)) != 0) {      // node is configured as CN
1506                                 // identify the node
1507                                 Ret =
1508                                     EplIdentuRequestIdentResponse(uiSubIndex,
1509                                                                   EplNmtMnuCbIdentResponse);
1510                                 if (Ret != kEplSuccessful) {
1511                                         goto Exit;
1512                                 }
1513                                 // set flag "not scanned"
1514                                 EPL_NMTMNU_GET_NODEINFO(uiSubIndex)->m_wFlags |=
1515                                     EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
1516                                 EplNmtMnuInstance_g.m_uiSignalSlaveCount++;
1517                                 // signal slave counter shall be decremented if IdentRequest was sent once to a CN
1518
1519                                 if ((dwNodeCfg & EPL_NODEASSIGN_MANDATORY_CN) != 0) {   // node is a mandatory CN
1520                                         EplNmtMnuInstance_g.
1521                                             m_uiMandatorySlaveCount++;
1522                                         // mandatory slave counter shall be decremented if mandatory CN was configured successfully
1523                                 }
1524                         }
1525                 } else {        // subindex of MN
1526                         if ((dwNodeCfg & (EPL_NODEASSIGN_MN_PRES | EPL_NODEASSIGN_NODE_EXISTS)) != 0) { // MN shall send PRes
1527                                 tEplDllNodeInfo DllNodeInfo;
1528
1529                                 EPL_MEMSET(&DllNodeInfo, 0,
1530                                            sizeof(DllNodeInfo));
1531                                 DllNodeInfo.m_uiNodeId = uiLocalNodeId;
1532
1533                                 Ret = EplDlluCalAddNode(&DllNodeInfo);
1534                         }
1535                 }
1536         }
1537
1538       Exit:
1539         return Ret;
1540 }
1541
1542 //---------------------------------------------------------------------------
1543 //
1544 // Function:    EplNmtMnuStartBootStep2
1545 //
1546 // Description: starts BootStep2.
1547 //              That means add nodes to isochronous phase and send
1548 //              NMT EnableReadyToOp.
1549 //
1550 // Parameters:  (none)
1551 //
1552 // Returns:     tEplKernel              = error code
1553 //
1554 // State:
1555 //
1556 //---------------------------------------------------------------------------
1557
1558 static tEplKernel EplNmtMnuStartBootStep2(void)
1559 {
1560         tEplKernel Ret = kEplSuccessful;
1561         unsigned int uiIndex;
1562         tEplNmtMnuNodeInfo *pNodeInfo;
1563
1564         if ((EplNmtMnuInstance_g.m_wFlags & EPL_NMTMNU_FLAG_HALTED) == 0) {     // boot process is not halted
1565                 // add nodes to isochronous phase and send NMT EnableReadyToOp
1566                 EplNmtMnuInstance_g.m_uiMandatorySlaveCount = 0;
1567                 EplNmtMnuInstance_g.m_uiSignalSlaveCount = 0;
1568                 // reset flag that application was informed about possible state change
1569                 EplNmtMnuInstance_g.m_wFlags &= ~EPL_NMTMNU_FLAG_APP_INFORMED;
1570
1571                 pNodeInfo = EplNmtMnuInstance_g.m_aNodeInfo;
1572                 for (uiIndex = 1;
1573                      uiIndex <= tabentries(EplNmtMnuInstance_g.m_aNodeInfo);
1574                      uiIndex++, pNodeInfo++) {
1575                         if (pNodeInfo->m_NodeState ==
1576                             kEplNmtMnuNodeStateConfigured) {
1577                                 Ret =
1578                                     EplNmtMnuNodeBootStep2(uiIndex, pNodeInfo);
1579                                 if (Ret != kEplSuccessful) {
1580                                         goto Exit;
1581                                 }
1582                                 // set flag "not scanned"
1583                                 pNodeInfo->m_wFlags |=
1584                                     EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
1585
1586                                 EplNmtMnuInstance_g.m_uiSignalSlaveCount++;
1587                                 // signal slave counter shall be decremented if StatusRequest was sent once to a CN
1588
1589                                 if ((pNodeInfo->m_dwNodeCfg & EPL_NODEASSIGN_MANDATORY_CN) != 0) {      // node is a mandatory CN
1590                                         EplNmtMnuInstance_g.
1591                                             m_uiMandatorySlaveCount++;
1592                                 }
1593                                 // mandatory slave counter shall be decremented if mandatory CN is ReadyToOp
1594                         }
1595                 }
1596         }
1597
1598       Exit:
1599         return Ret;
1600 }
1601
1602 //---------------------------------------------------------------------------
1603 //
1604 // Function:    EplNmtMnuNodeBootStep2
1605 //
1606 // Description: starts BootStep2 for the specified node.
1607 //              This means the CN is added to isochronous phase if not
1608 //              async-only and it gets the NMT command EnableReadyToOp.
1609 //              The CN must be in node state Configured, when it enters
1610 //              BootStep2. When BootStep2 finishes, the CN is in node state
1611 //              ReadyToOp.
1612 //              If TimeoutReadyToOp in object 0x1F89/5 is configured,
1613 //              TimerHdlLonger will be started with this timeout.
1614 //
1615 // Parameters:  uiNodeId_p              = node ID
1616 //              pNodeInfo_p             = pointer to internal node info structure
1617 //
1618 // Returns:     tEplKernel              = error code
1619 //
1620 // State:
1621 //
1622 //---------------------------------------------------------------------------
1623
1624 static tEplKernel EplNmtMnuNodeBootStep2(unsigned int uiNodeId_p,
1625                                          tEplNmtMnuNodeInfo * pNodeInfo_p)
1626 {
1627         tEplKernel Ret = kEplSuccessful;
1628         tEplDllNodeInfo DllNodeInfo;
1629         u32 dwNodeCfg;
1630         tEplObdSize ObdSize;
1631         tEplTimerArg TimerArg;
1632
1633         dwNodeCfg = pNodeInfo_p->m_dwNodeCfg;
1634         if ((dwNodeCfg & EPL_NODEASSIGN_ASYNCONLY_NODE) == 0) { // add node to isochronous phase
1635                 DllNodeInfo.m_uiNodeId = uiNodeId_p;
1636                 ObdSize = 4;
1637                 Ret =
1638                     EplObduReadEntry(0x1F92, uiNodeId_p,
1639                                      &DllNodeInfo.m_dwPresTimeout, &ObdSize);
1640                 if (Ret != kEplSuccessful) {
1641                         goto Exit;
1642                 }
1643
1644                 ObdSize = 2;
1645                 Ret =
1646                     EplObduReadEntry(0x1F8B, uiNodeId_p,
1647                                      &DllNodeInfo.m_wPreqPayloadLimit,
1648                                      &ObdSize);
1649                 if (Ret != kEplSuccessful) {
1650                         goto Exit;
1651                 }
1652
1653                 ObdSize = 2;
1654                 Ret =
1655                     EplObduReadEntry(0x1F8D, uiNodeId_p,
1656                                      &DllNodeInfo.m_wPresPayloadLimit,
1657                                      &ObdSize);
1658                 if (Ret != kEplSuccessful) {
1659                         goto Exit;
1660                 }
1661
1662                 pNodeInfo_p->m_wFlags |= EPL_NMTMNU_NODE_FLAG_ISOCHRON;
1663
1664                 Ret = EplDlluCalAddNode(&DllNodeInfo);
1665                 if (Ret != kEplSuccessful) {
1666                         goto Exit;
1667                 }
1668
1669         }
1670
1671         EPL_NMTMNU_DBG_POST_TRACE_VALUE(0,
1672                                         uiNodeId_p,
1673                                         kEplNmtCmdEnableReadyToOperate);
1674
1675         Ret =
1676             EplNmtMnuSendNmtCommand(uiNodeId_p, kEplNmtCmdEnableReadyToOperate);
1677         if (Ret != kEplSuccessful) {
1678                 goto Exit;
1679         }
1680
1681         if (EplNmtMnuInstance_g.m_ulTimeoutReadyToOp != 0L) {   // start timer
1682                 // when the timer expires the CN must be ReadyToOp
1683                 EPL_NMTMNU_SET_FLAGS_TIMERARG_LONGER(pNodeInfo_p, uiNodeId_p,
1684                                                      TimerArg);
1685 //        TimerArg.m_EventSink = kEplEventSinkNmtMnu;
1686 //        TimerArg.m_ulArg = EPL_NMTMNU_TIMERARG_LONGER | uiNodeId_p;
1687                 Ret =
1688                     EplTimeruModifyTimerMs(&pNodeInfo_p->m_TimerHdlLonger,
1689                                            EplNmtMnuInstance_g.
1690                                            m_ulTimeoutReadyToOp, TimerArg);
1691         }
1692
1693       Exit:
1694         return Ret;
1695 }
1696
1697 //---------------------------------------------------------------------------
1698 //
1699 // Function:    EplNmtMnuStartCheckCom
1700 //
1701 // Description: starts CheckCommunication
1702 //
1703 // Parameters:  (none)
1704 //
1705 // Returns:     tEplKernel              = error code
1706 //
1707 // State:
1708 //
1709 //---------------------------------------------------------------------------
1710
1711 static tEplKernel EplNmtMnuStartCheckCom(void)
1712 {
1713         tEplKernel Ret = kEplSuccessful;
1714         unsigned int uiIndex;
1715         tEplNmtMnuNodeInfo *pNodeInfo;
1716
1717         if ((EplNmtMnuInstance_g.m_wFlags & EPL_NMTMNU_FLAG_HALTED) == 0) {     // boot process is not halted
1718                 // wait some time and check that no communication error occurs
1719                 EplNmtMnuInstance_g.m_uiMandatorySlaveCount = 0;
1720                 EplNmtMnuInstance_g.m_uiSignalSlaveCount = 0;
1721                 // reset flag that application was informed about possible state change
1722                 EplNmtMnuInstance_g.m_wFlags &= ~EPL_NMTMNU_FLAG_APP_INFORMED;
1723
1724                 pNodeInfo = EplNmtMnuInstance_g.m_aNodeInfo;
1725                 for (uiIndex = 1;
1726                      uiIndex <= tabentries(EplNmtMnuInstance_g.m_aNodeInfo);
1727                      uiIndex++, pNodeInfo++) {
1728                         if (pNodeInfo->m_NodeState ==
1729                             kEplNmtMnuNodeStateReadyToOp) {
1730                                 Ret = EplNmtMnuNodeCheckCom(uiIndex, pNodeInfo);
1731                                 if (Ret == kEplReject) {        // timer was started
1732                                         // wait until it expires
1733                                         if ((pNodeInfo->m_dwNodeCfg & EPL_NODEASSIGN_MANDATORY_CN) != 0) {      // node is a mandatory CN
1734                                                 EplNmtMnuInstance_g.
1735                                                     m_uiMandatorySlaveCount++;
1736                                         }
1737                                 } else if (Ret != kEplSuccessful) {
1738                                         goto Exit;
1739                                 }
1740                                 // set flag "not scanned"
1741                                 pNodeInfo->m_wFlags |=
1742                                     EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
1743
1744                                 EplNmtMnuInstance_g.m_uiSignalSlaveCount++;
1745                                 // signal slave counter shall be decremented if timeout elapsed and regardless of an error
1746                                 // mandatory slave counter shall be decremented if timeout elapsed and no error occured
1747                         }
1748                 }
1749         }
1750
1751         Ret = kEplSuccessful;
1752
1753       Exit:
1754         return Ret;
1755 }
1756
1757 //---------------------------------------------------------------------------
1758 //
1759 // Function:    EplNmtMnuNodeCheckCom
1760 //
1761 // Description: checks communication of the specified node.
1762 //              That means wait some time and if no error occured everything
1763 //              is OK.
1764 //
1765 // Parameters:  uiNodeId_p              = node ID
1766 //              pNodeInfo_p             = pointer to internal node info structure
1767 //
1768 // Returns:     tEplKernel              = error code
1769 //
1770 // State:
1771 //
1772 //---------------------------------------------------------------------------
1773
1774 static tEplKernel EplNmtMnuNodeCheckCom(unsigned int uiNodeId_p,
1775                                         tEplNmtMnuNodeInfo * pNodeInfo_p)
1776 {
1777         tEplKernel Ret = kEplSuccessful;
1778         u32 dwNodeCfg;
1779         tEplTimerArg TimerArg;
1780
1781         dwNodeCfg = pNodeInfo_p->m_dwNodeCfg;
1782         if (((dwNodeCfg & EPL_NODEASSIGN_ASYNCONLY_NODE) == 0)
1783             && (EplNmtMnuInstance_g.m_ulTimeoutCheckCom != 0L)) {       // CN is not async-only and timeout for CheckCom was set
1784
1785                 // check communication,
1786                 // that means wait some time and if no error occured everything is OK;
1787
1788                 // start timer (when the timer expires the CN must be still ReadyToOp)
1789                 EPL_NMTMNU_SET_FLAGS_TIMERARG_LONGER(pNodeInfo_p, uiNodeId_p,
1790                                                      TimerArg);
1791 //        TimerArg.m_EventSink = kEplEventSinkNmtMnu;
1792 //        TimerArg.m_ulArg = EPL_NMTMNU_TIMERARG_LONGER | uiNodeId_p;
1793                 Ret =
1794                     EplTimeruModifyTimerMs(&pNodeInfo_p->m_TimerHdlLonger,
1795                                            EplNmtMnuInstance_g.
1796                                            m_ulTimeoutCheckCom, TimerArg);
1797
1798                 // update mandatory slave counter, because timer was started
1799                 if (Ret == kEplSuccessful) {
1800                         Ret = kEplReject;
1801                 }
1802         } else {                // timer was not started
1803                 // assume everything is OK
1804                 pNodeInfo_p->m_NodeState = kEplNmtMnuNodeStateComChecked;
1805         }
1806
1807 //Exit:
1808         return Ret;
1809 }
1810
1811 //---------------------------------------------------------------------------
1812 //
1813 // Function:    EplNmtMnuStartNodes
1814 //
1815 // Description: really starts all nodes which are ReadyToOp and CheckCom did not fail
1816 //
1817 // Parameters:  (none)
1818 //
1819 // Returns:     tEplKernel              = error code
1820 //
1821 // State:
1822 //
1823 //---------------------------------------------------------------------------
1824
1825 static tEplKernel EplNmtMnuStartNodes(void)
1826 {
1827         tEplKernel Ret = kEplSuccessful;
1828         unsigned int uiIndex;
1829         tEplNmtMnuNodeInfo *pNodeInfo;
1830
1831         if ((EplNmtMnuInstance_g.m_wFlags & EPL_NMTMNU_FLAG_HALTED) == 0) {     // boot process is not halted
1832                 // send NMT command Start Node
1833                 EplNmtMnuInstance_g.m_uiMandatorySlaveCount = 0;
1834                 EplNmtMnuInstance_g.m_uiSignalSlaveCount = 0;
1835                 // reset flag that application was informed about possible state change
1836                 EplNmtMnuInstance_g.m_wFlags &= ~EPL_NMTMNU_FLAG_APP_INFORMED;
1837
1838                 pNodeInfo = EplNmtMnuInstance_g.m_aNodeInfo;
1839                 for (uiIndex = 1;
1840                      uiIndex <= tabentries(EplNmtMnuInstance_g.m_aNodeInfo);
1841                      uiIndex++, pNodeInfo++) {
1842                         if (pNodeInfo->m_NodeState ==
1843                             kEplNmtMnuNodeStateComChecked) {
1844                                 if ((EplNmtMnuInstance_g.
1845                                      m_dwNmtStartup & EPL_NMTST_STARTALLNODES)
1846                                     == 0) {
1847                                         EPL_NMTMNU_DBG_POST_TRACE_VALUE(0,
1848                                                                         uiIndex,
1849                                                                         kEplNmtCmdStartNode);
1850
1851                                         Ret =
1852                                             EplNmtMnuSendNmtCommand(uiIndex,
1853                                                                     kEplNmtCmdStartNode);
1854                                         if (Ret != kEplSuccessful) {
1855                                                 goto Exit;
1856                                         }
1857                                 }
1858
1859                                 if ((pNodeInfo->m_dwNodeCfg & EPL_NODEASSIGN_MANDATORY_CN) != 0) {      // node is a mandatory CN
1860                                         EplNmtMnuInstance_g.
1861                                             m_uiMandatorySlaveCount++;
1862                                 }
1863                                 // set flag "not scanned"
1864                                 pNodeInfo->m_wFlags |=
1865                                     EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
1866
1867                                 EplNmtMnuInstance_g.m_uiSignalSlaveCount++;
1868                                 // signal slave counter shall be decremented if StatusRequest was sent once to a CN
1869                                 // mandatory slave counter shall be decremented if mandatory CN is OPERATIONAL
1870                         }
1871                 }
1872
1873                 // $$$ inform application if EPL_NMTST_NO_STARTNODE is set
1874
1875                 if ((EplNmtMnuInstance_g.
1876                      m_dwNmtStartup & EPL_NMTST_STARTALLNODES) != 0) {
1877                         EPL_NMTMNU_DBG_POST_TRACE_VALUE(0, EPL_C_ADR_BROADCAST,
1878                                                         kEplNmtCmdStartNode);
1879
1880                         Ret =
1881                             EplNmtMnuSendNmtCommand(EPL_C_ADR_BROADCAST,
1882                                                     kEplNmtCmdStartNode);
1883                         if (Ret != kEplSuccessful) {
1884                                 goto Exit;
1885                         }
1886                 }
1887         }
1888
1889       Exit:
1890         return Ret;
1891 }
1892
1893 //---------------------------------------------------------------------------
1894 //
1895 // Function:    EplNmtMnuProcessInternalEvent
1896 //
1897 // Description: processes internal node events
1898 //
1899 // Parameters:  uiNodeId_p              = node ID
1900 //              NodeNmtState_p          = NMT state of CN
1901 //              NodeEvent_p             = occured events
1902 //
1903 // Returns:     tEplKernel              = error code
1904 //
1905 //
1906 // State:
1907 //
1908 //---------------------------------------------------------------------------
1909
1910 static tEplKernel EplNmtMnuProcessInternalEvent(unsigned int uiNodeId_p,
1911                                                 tEplNmtState NodeNmtState_p,
1912                                                 u16 wErrorCode_p,
1913                                                 tEplNmtMnuIntNodeEvent
1914                                                 NodeEvent_p)
1915 {
1916         tEplKernel Ret = kEplSuccessful;
1917         tEplNmtState NmtState;
1918         tEplNmtMnuNodeInfo *pNodeInfo;
1919         tEplTimerArg TimerArg;
1920
1921         pNodeInfo = EPL_NMTMNU_GET_NODEINFO(uiNodeId_p);
1922         NmtState = EplNmtuGetNmtState();
1923         if (NmtState <= kEplNmtMsNotActive) {   // MN is not active
1924                 goto Exit;
1925         }
1926
1927         switch (NodeEvent_p) {
1928         case kEplNmtMnuIntNodeEventIdentResponse:
1929                 {
1930                         u8 bNmtState;
1931
1932                         EPL_NMTMNU_DBG_POST_TRACE_VALUE(NodeEvent_p,
1933                                                         uiNodeId_p,
1934                                                         pNodeInfo->m_NodeState);
1935
1936                         if (pNodeInfo->m_NodeState !=
1937                             kEplNmtMnuNodeStateResetConf) {
1938                                 pNodeInfo->m_NodeState =
1939                                     kEplNmtMnuNodeStateIdentified;
1940                         }
1941                         // reset flags ISOCHRON and NMT_CMD_ISSUED
1942                         pNodeInfo->m_wFlags &= ~(EPL_NMTMNU_NODE_FLAG_ISOCHRON
1943                                                  |
1944                                                  EPL_NMTMNU_NODE_FLAG_NMT_CMD_ISSUED);
1945
1946                         if ((NmtState == kEplNmtMsPreOperational1)
1947                             &&
1948                             ((pNodeInfo->
1949                               m_wFlags & EPL_NMTMNU_NODE_FLAG_NOT_SCANNED) !=
1950                              0)) {
1951                                 // decrement only signal slave count
1952                                 EplNmtMnuInstance_g.m_uiSignalSlaveCount--;
1953                                 pNodeInfo->m_wFlags &=
1954                                     ~EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
1955                         }
1956                         // update object 0x1F8F NMT_MNNodeExpState_AU8 to PreOp1 (even if local state >= PreOp2)
1957                         bNmtState = (u8) (kEplNmtCsPreOperational1 & 0xFF);
1958                         Ret =
1959                             EplObduWriteEntry(0x1F8F, uiNodeId_p, &bNmtState,
1960                                               1);
1961
1962                         // check NMT state of CN
1963                         Ret =
1964                             EplNmtMnuCheckNmtState(uiNodeId_p, pNodeInfo,
1965                                                    NodeNmtState_p, wErrorCode_p,
1966                                                    NmtState);
1967                         if (Ret != kEplSuccessful) {
1968                                 if (Ret == kEplReject) {
1969                                         Ret = kEplSuccessful;
1970                                 }
1971                                 break;
1972                         }
1973                         // request StatusResponse immediately,
1974                         // because we want a fast boot-up of CNs
1975                         Ret =
1976                             EplStatusuRequestStatusResponse(uiNodeId_p,
1977                                                             EplNmtMnuCbStatusResponse);
1978                         if (Ret != kEplSuccessful) {
1979                                 EPL_NMTMNU_DBG_POST_TRACE_VALUE(NodeEvent_p,
1980                                                                 uiNodeId_p,
1981                                                                 Ret);
1982
1983                                 if (Ret == kEplInvalidOperation) {      // the only situation when this should happen is, when
1984                                         // StatusResponse was already requested from within
1985                                         // the StatReq timer event.
1986                                         // so ignore this error.
1987                                         Ret = kEplSuccessful;
1988                                 } else {
1989                                         break;
1990                                 }
1991                         }
1992
1993                         if (pNodeInfo->m_NodeState !=
1994                             kEplNmtMnuNodeStateResetConf) {
1995                                 // inform application
1996                                 Ret =
1997                                     EplNmtMnuInstance_g.
1998                                     m_pfnCbNodeEvent(uiNodeId_p,
1999                                                      kEplNmtNodeEventFound,
2000                                                      NodeNmtState_p,
2001                                                      EPL_E_NO_ERROR,
2002                                                      (pNodeInfo->
2003                                                       m_dwNodeCfg &
2004                                                       EPL_NODEASSIGN_MANDATORY_CN)
2005                                                      != 0);
2006                                 if (Ret == kEplReject) {        // interrupt boot process on user request
2007                                         EPL_NMTMNU_DBG_POST_TRACE_VALUE
2008                                             (NodeEvent_p, uiNodeId_p,
2009                                              ((pNodeInfo->m_NodeState << 8)
2010                                               | Ret));
2011
2012                                         Ret = kEplSuccessful;
2013                                         break;
2014                                 } else if (Ret != kEplSuccessful) {
2015                                         EPL_NMTMNU_DBG_POST_TRACE_VALUE
2016                                             (NodeEvent_p, uiNodeId_p,
2017                                              ((pNodeInfo->m_NodeState << 8)
2018                                               | Ret));
2019
2020                                         break;
2021                                 }
2022                         }
2023                         // continue BootStep1
2024                 }
2025
2026         case kEplNmtMnuIntNodeEventBoot:
2027                 {
2028
2029                         // $$$ check identification (vendor ID, product code, revision no, serial no)
2030
2031                         if (pNodeInfo->m_NodeState ==
2032                             kEplNmtMnuNodeStateIdentified) {
2033                                 // $$$ check software
2034
2035                                 // check/start configuration
2036                                 // inform application
2037                                 Ret =
2038                                     EplNmtMnuInstance_g.
2039                                     m_pfnCbNodeEvent(uiNodeId_p,
2040                                                      kEplNmtNodeEventCheckConf,
2041                                                      NodeNmtState_p,
2042                                                      EPL_E_NO_ERROR,
2043                                                      (pNodeInfo->
2044                                                       m_dwNodeCfg &
2045                                                       EPL_NODEASSIGN_MANDATORY_CN)
2046                                                      != 0);
2047                                 if (Ret == kEplReject) {        // interrupt boot process on user request
2048                                         EPL_NMTMNU_DBG_POST_TRACE_VALUE
2049                                             (kEplNmtMnuIntNodeEventBoot,
2050                                              uiNodeId_p,
2051                                              ((pNodeInfo->m_NodeState << 8)
2052                                               | Ret));
2053
2054                                         Ret = kEplSuccessful;
2055                                         break;
2056                                 } else if (Ret != kEplSuccessful) {
2057                                         EPL_NMTMNU_DBG_POST_TRACE_VALUE
2058                                             (kEplNmtMnuIntNodeEventBoot,
2059                                              uiNodeId_p,
2060                                              ((pNodeInfo->m_NodeState << 8)
2061                                               | Ret));
2062
2063                                         break;
2064                                 }
2065                         } else if (pNodeInfo->m_NodeState != kEplNmtMnuNodeStateResetConf) {    // wrong CN state
2066                                 // ignore event
2067                                 break;
2068                         }
2069                         // $$$ d.k.: currently we assume configuration is OK
2070
2071                         // continue BootStep1
2072                 }
2073
2074         case kEplNmtMnuIntNodeEventConfigured:
2075                 {
2076                         if ((pNodeInfo->m_NodeState !=
2077                              kEplNmtMnuNodeStateIdentified)
2078                             && (pNodeInfo->m_NodeState != kEplNmtMnuNodeStateResetConf)) {      // wrong CN state
2079                                 // ignore event
2080                                 break;
2081                         }
2082
2083                         pNodeInfo->m_NodeState = kEplNmtMnuNodeStateConfigured;
2084
2085                         if (NmtState == kEplNmtMsPreOperational1) {
2086                                 if ((pNodeInfo->m_dwNodeCfg & EPL_NODEASSIGN_MANDATORY_CN) != 0) {      // decrement mandatory CN counter
2087                                         EplNmtMnuInstance_g.
2088                                             m_uiMandatorySlaveCount--;
2089                                 }
2090                         } else {
2091                                 // put optional node to next step (BootStep2)
2092                                 Ret =
2093                                     EplNmtMnuNodeBootStep2(uiNodeId_p,
2094                                                            pNodeInfo);
2095                         }
2096                         break;
2097                 }
2098
2099         case kEplNmtMnuIntNodeEventNoIdentResponse:
2100                 {
2101                         if ((NmtState == kEplNmtMsPreOperational1)
2102                             &&
2103                             ((pNodeInfo->
2104                               m_wFlags & EPL_NMTMNU_NODE_FLAG_NOT_SCANNED) !=
2105                              0)) {
2106                                 // decrement only signal slave count
2107                                 EplNmtMnuInstance_g.m_uiSignalSlaveCount--;
2108                                 pNodeInfo->m_wFlags &=
2109                                     ~EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
2110                         }
2111
2112                         if (pNodeInfo->m_NodeState !=
2113                             kEplNmtMnuNodeStateResetConf) {
2114                                 pNodeInfo->m_NodeState =
2115                                     kEplNmtMnuNodeStateUnknown;
2116                         }
2117                         // $$$ d.k. check start time for 0x1F89/2 MNTimeoutPreOp1_U32
2118                         // $$$ d.k. check individual timeout 0x1F89/6 MNIdentificationTimeout_U32
2119                         // if mandatory node and timeout elapsed -> halt boot procedure
2120                         // trigger IdentRequest again (if >= PreOp2, after delay)
2121                         if (NmtState >= kEplNmtMsPreOperational2) {     // start timer
2122                                 EPL_NMTMNU_SET_FLAGS_TIMERARG_IDENTREQ
2123                                     (pNodeInfo, uiNodeId_p, TimerArg);
2124 //                TimerArg.m_EventSink = kEplEventSinkNmtMnu;
2125 //                TimerArg.m_ulArg = EPL_NMTMNU_TIMERARG_IDENTREQ | uiNodeId_p;
2126 /*
2127                 EPL_NMTMNU_DBG_POST_TRACE_VALUE(kEplNmtMnuIntNodeEventNoIdentResponse,
2128                                                 uiNodeId_p,
2129                                                 ((pNodeInfo->m_NodeState << 8)
2130                                                  | 0x80
2131                                                  | ((pNodeInfo->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ) >> 6)
2132                                                  | ((TimerArg.m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_SR) >> 8)));
2133 */
2134                                 Ret =
2135                                     EplTimeruModifyTimerMs(&pNodeInfo->
2136                                                            m_TimerHdlStatReq,
2137                                                            EplNmtMnuInstance_g.
2138                                                            m_ulStatusRequestDelay,
2139                                                            TimerArg);
2140                         } else {        // trigger IdentRequest immediately
2141                                 Ret =
2142                                     EplIdentuRequestIdentResponse(uiNodeId_p,
2143                                                                   EplNmtMnuCbIdentResponse);
2144                         }
2145                         break;
2146                 }
2147
2148         case kEplNmtMnuIntNodeEventStatusResponse:
2149                 {
2150                         if ((NmtState >= kEplNmtMsPreOperational2)
2151                             &&
2152                             ((pNodeInfo->
2153                               m_wFlags & EPL_NMTMNU_NODE_FLAG_NOT_SCANNED) !=
2154                              0)) {
2155                                 // decrement only signal slave count if checked once for ReadyToOp, CheckCom, Operational
2156                                 EplNmtMnuInstance_g.m_uiSignalSlaveCount--;
2157                                 pNodeInfo->m_wFlags &=
2158                                     ~EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
2159                         }
2160                         // check NMT state of CN
2161                         Ret =
2162                             EplNmtMnuCheckNmtState(uiNodeId_p, pNodeInfo,
2163                                                    NodeNmtState_p, wErrorCode_p,
2164                                                    NmtState);
2165                         if (Ret != kEplSuccessful) {
2166                                 if (Ret == kEplReject) {
2167                                         Ret = kEplSuccessful;
2168                                 }
2169                                 break;
2170                         }
2171
2172                         if (NmtState == kEplNmtMsPreOperational1) {
2173                                 // request next StatusResponse immediately
2174                                 Ret =
2175                                     EplStatusuRequestStatusResponse(uiNodeId_p,
2176                                                                     EplNmtMnuCbStatusResponse);
2177                                 if (Ret != kEplSuccessful) {
2178                                         EPL_NMTMNU_DBG_POST_TRACE_VALUE
2179                                             (NodeEvent_p, uiNodeId_p, Ret);
2180                                 }
2181
2182                         } else if ((pNodeInfo->m_wFlags & EPL_NMTMNU_NODE_FLAG_ISOCHRON) == 0) {        // start timer
2183                                 // not isochronously accessed CN (e.g. async-only or stopped CN)
2184                                 EPL_NMTMNU_SET_FLAGS_TIMERARG_STATREQ(pNodeInfo,
2185                                                                       uiNodeId_p,
2186                                                                       TimerArg);
2187 //                TimerArg.m_EventSink = kEplEventSinkNmtMnu;
2188 //                TimerArg.m_ulArg = EPL_NMTMNU_TIMERARG_STATREQ | uiNodeId_p;
2189 /*
2190                 EPL_NMTMNU_DBG_POST_TRACE_VALUE(kEplNmtMnuIntNodeEventStatusResponse,
2191                                                 uiNodeId_p,
2192                                                 ((pNodeInfo->m_NodeState << 8)
2193                                                  | 0x80
2194                                                  | ((pNodeInfo->m_wFlags & EPL_NMTMNU_NODE_FLAG_COUNT_STATREQ) >> 6)
2195                                                  | ((TimerArg.m_ulArg & EPL_NMTMNU_TIMERARG_COUNT_SR) >> 8)));
2196 */
2197                                 Ret =
2198                                     EplTimeruModifyTimerMs(&pNodeInfo->
2199                                                            m_TimerHdlStatReq,
2200                                                            EplNmtMnuInstance_g.
2201                                                            m_ulStatusRequestDelay,
2202                                                            TimerArg);
2203                         }
2204
2205                         break;
2206                 }
2207
2208         case kEplNmtMnuIntNodeEventNoStatusResponse:
2209                 {
2210                         // function CheckNmtState sets node state to unknown if necessary
2211 /*
2212             if ((NmtState >= kEplNmtMsPreOperational2)
2213                 && ((pNodeInfo->m_wFlags & EPL_NMTMNU_NODE_FLAG_NOT_SCANNED) != 0))
2214             {
2215                 // decrement only signal slave count if checked once for ReadyToOp, CheckCom, Operational
2216                 EplNmtMnuInstance_g.m_uiSignalSlaveCount--;
2217                 pNodeInfo->m_wFlags &= ~EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
2218             }
2219 */
2220                         // check NMT state of CN
2221                         Ret =
2222                             EplNmtMnuCheckNmtState(uiNodeId_p, pNodeInfo,
2223                                                    NodeNmtState_p, wErrorCode_p,
2224                                                    NmtState);
2225                         if (Ret != kEplSuccessful) {
2226                                 if (Ret == kEplReject) {
2227                                         Ret = kEplSuccessful;
2228                                 }
2229                                 break;
2230                         }
2231
2232                         break;
2233                 }
2234
2235         case kEplNmtMnuIntNodeEventError:
2236                 {               // currently only issued on kEplNmtNodeCommandConfErr
2237
2238                         if (pNodeInfo->m_NodeState != kEplNmtMnuNodeStateIdentified) {  // wrong CN state
2239                                 // ignore event
2240                                 break;
2241                         }
2242                         // check NMT state of CN
2243                         Ret =
2244                             EplNmtMnuCheckNmtState(uiNodeId_p, pNodeInfo,
2245                                                    kEplNmtCsNotActive,
2246                                                    wErrorCode_p, NmtState);
2247                         if (Ret != kEplSuccessful) {
2248                                 if (Ret == kEplReject) {
2249                                         Ret = kEplSuccessful;
2250                                 }
2251                                 break;
2252                         }
2253
2254                         break;
2255                 }
2256
2257         case kEplNmtMnuIntNodeEventExecReset:
2258                 {
2259                         if (pNodeInfo->m_NodeState != kEplNmtMnuNodeStateIdentified) {  // wrong CN state
2260                                 // ignore event
2261                                 break;
2262                         }
2263
2264                         pNodeInfo->m_NodeState = kEplNmtMnuNodeStateResetConf;
2265
2266                         EPL_NMTMNU_DBG_POST_TRACE_VALUE(NodeEvent_p,
2267                                                         uiNodeId_p,
2268                                                         (((NodeNmtState_p &
2269                                                            0xFF) << 8)
2270                                                          |
2271                                                          kEplNmtCmdResetConfiguration));
2272
2273                         // send NMT reset configuration to CN for activation of configuration
2274                         Ret =
2275                             EplNmtMnuSendNmtCommand(uiNodeId_p,
2276                                                     kEplNmtCmdResetConfiguration);
2277
2278                         break;
2279                 }
2280
2281         case kEplNmtMnuIntNodeEventHeartbeat:
2282                 {
2283 /*
2284             if ((NmtState >= kEplNmtMsPreOperational2)
2285                 && ((pNodeInfo->m_wFlags & EPL_NMTMNU_NODE_FLAG_NOT_SCANNED) != 0))
2286             {
2287                 // decrement only signal slave count if checked once for ReadyToOp, CheckCom, Operational
2288                 EplNmtMnuInstance_g.m_uiSignalSlaveCount--;
2289                 pNodeInfo->m_wFlags &= ~EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
2290             }
2291 */
2292                         // check NMT state of CN
2293                         Ret =
2294                             EplNmtMnuCheckNmtState(uiNodeId_p, pNodeInfo,
2295                                                    NodeNmtState_p, wErrorCode_p,
2296                                                    NmtState);
2297                         if (Ret != kEplSuccessful) {
2298                                 if (Ret == kEplReject) {
2299                                         Ret = kEplSuccessful;
2300                                 }
2301                                 break;
2302                         }
2303
2304                         break;
2305                 }
2306
2307         case kEplNmtMnuIntNodeEventTimerIdentReq:
2308                 {
2309                         EPL_DBGLVL_NMTMN_TRACE1
2310                             ("TimerStatReq->IdentReq(%02X)\n", uiNodeId_p);
2311                         // trigger IdentRequest again
2312                         Ret =
2313                             EplIdentuRequestIdentResponse(uiNodeId_p,
2314                                                           EplNmtMnuCbIdentResponse);
2315                         if (Ret != kEplSuccessful) {
2316                                 EPL_NMTMNU_DBG_POST_TRACE_VALUE(NodeEvent_p,
2317                                                                 uiNodeId_p,
2318                                                                 (((NodeNmtState_p & 0xFF) << 8)
2319                                                                  | Ret));
2320                                 if (Ret == kEplInvalidOperation) {      // this can happen because of a bug in EplTimeruLinuxKernel.c
2321                                         // so ignore this error.
2322                                         Ret = kEplSuccessful;
2323                                 }
2324                         }
2325
2326                         break;
2327                 }
2328
2329         case kEplNmtMnuIntNodeEventTimerStateMon:
2330                 {
2331                         // reset NMT state change flag
2332                         // because from now on the CN must have the correct NMT state
2333                         pNodeInfo->m_wFlags &=
2334                             ~EPL_NMTMNU_NODE_FLAG_NMT_CMD_ISSUED;
2335
2336                         // continue with normal StatReq processing
2337                 }
2338
2339         case kEplNmtMnuIntNodeEventTimerStatReq:
2340                 {
2341                         EPL_DBGLVL_NMTMN_TRACE1("TimerStatReq->StatReq(%02X)\n",
2342                                                 uiNodeId_p);
2343                         // request next StatusResponse
2344                         Ret =
2345                             EplStatusuRequestStatusResponse(uiNodeId_p,
2346                                                             EplNmtMnuCbStatusResponse);
2347                         if (Ret != kEplSuccessful) {
2348                                 EPL_NMTMNU_DBG_POST_TRACE_VALUE(NodeEvent_p,
2349                                                                 uiNodeId_p,
2350                                                                 (((NodeNmtState_p & 0xFF) << 8)
2351                                                                  | Ret));
2352                                 if (Ret == kEplInvalidOperation) {      // the only situation when this should happen is, when
2353                                         // StatusResponse was already requested while processing
2354                                         // event IdentResponse.
2355                                         // so ignore this error.
2356                                         Ret = kEplSuccessful;
2357                                 }
2358                         }
2359
2360                         break;
2361                 }
2362
2363         case kEplNmtMnuIntNodeEventTimerLonger:
2364                 {
2365                         switch (pNodeInfo->m_NodeState) {
2366                         case kEplNmtMnuNodeStateConfigured:
2367                                 {       // node should be ReadyToOp but it is not
2368
2369                                         // check NMT state which shall be intentionally wrong, so that ERROR_TREATMENT will be started
2370                                         Ret =
2371                                             EplNmtMnuCheckNmtState(uiNodeId_p,
2372                                                                    pNodeInfo,
2373                                                                    kEplNmtCsNotActive,
2374                                                                    EPL_E_NMT_BPO2,
2375                                                                    NmtState);
2376                                         if (Ret != kEplSuccessful) {
2377                                                 if (Ret == kEplReject) {
2378                                                         Ret = kEplSuccessful;
2379                                                 }
2380                                                 break;
2381                                         }
2382
2383                                         break;
2384                                 }
2385
2386                         case kEplNmtMnuNodeStateReadyToOp:
2387                                 {       // CheckCom finished successfully
2388
2389                                         pNodeInfo->m_NodeState =
2390                                             kEplNmtMnuNodeStateComChecked;
2391
2392                                         if ((pNodeInfo->
2393                                              m_wFlags &
2394                                              EPL_NMTMNU_NODE_FLAG_NOT_SCANNED)
2395                                             != 0) {
2396                                                 // decrement only signal slave count if checked once for ReadyToOp, CheckCom, Operational
2397                                                 EplNmtMnuInstance_g.
2398                                                     m_uiSignalSlaveCount--;
2399                                                 pNodeInfo->m_wFlags &=
2400                                                     ~EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
2401                                         }
2402
2403                                         if ((pNodeInfo->
2404                                              m_dwNodeCfg &
2405                                              EPL_NODEASSIGN_MANDATORY_CN) !=
2406                                             0) {
2407                                                 // decrement mandatory slave counter
2408                                                 EplNmtMnuInstance_g.
2409                                                     m_uiMandatorySlaveCount--;
2410                                         }
2411                                         if (NmtState != kEplNmtMsReadyToOperate) {
2412                                                 EPL_NMTMNU_DBG_POST_TRACE_VALUE
2413                                                     (NodeEvent_p, uiNodeId_p,
2414                                                      (((NodeNmtState_p & 0xFF)
2415                                                        << 8)
2416                                                       | kEplNmtCmdStartNode));
2417
2418                                                 // start optional CN
2419                                                 Ret =
2420                                                     EplNmtMnuSendNmtCommand
2421                                                     (uiNodeId_p,
2422                                                      kEplNmtCmdStartNode);
2423                                         }
2424                                         break;
2425                                 }
2426
2427                         default:
2428                                 {
2429                                         break;
2430                                 }
2431                         }
2432                         break;
2433                 }
2434
2435         case kEplNmtMnuIntNodeEventNmtCmdSent:
2436                 {
2437                         u8 bNmtState;
2438
2439                         // update expected NMT state with the one that results
2440                         // from the sent NMT command
2441                         bNmtState = (u8) (NodeNmtState_p & 0xFF);
2442
2443                         // write object 0x1F8F NMT_MNNodeExpState_AU8
2444                         Ret =
2445                             EplObduWriteEntry(0x1F8F, uiNodeId_p, &bNmtState,
2446                                               1);
2447                         if (Ret != kEplSuccessful) {
2448                                 goto Exit;
2449                         }
2450
2451                         if (NodeNmtState_p == kEplNmtCsNotActive) {     // restart processing with IdentRequest
2452                                 EPL_NMTMNU_SET_FLAGS_TIMERARG_IDENTREQ
2453                                     (pNodeInfo, uiNodeId_p, TimerArg);
2454                         } else {        // monitor NMT state change with StatusRequest after
2455                                 // the corresponding delay;
2456                                 // until then wrong NMT states will be ignored
2457                                 EPL_NMTMNU_SET_FLAGS_TIMERARG_STATE_MON
2458                                     (pNodeInfo, uiNodeId_p, TimerArg);
2459
2460                                 // set NMT state change flag
2461                                 pNodeInfo->m_wFlags |=
2462                                     EPL_NMTMNU_NODE_FLAG_NMT_CMD_ISSUED;
2463                         }
2464
2465                         Ret =
2466                             EplTimeruModifyTimerMs(&pNodeInfo->
2467                                                    m_TimerHdlStatReq,
2468                                                    EplNmtMnuInstance_g.
2469                                                    m_ulStatusRequestDelay,
2470                                                    TimerArg);
2471
2472                         // finish processing, because NmtState_p is the expected and not the current state
2473                         goto Exit;
2474                 }
2475
2476         default:
2477                 {
2478                         break;
2479                 }
2480         }
2481
2482         // check if network is ready to change local NMT state and this was not done before
2483         if ((EplNmtMnuInstance_g.m_wFlags & (EPL_NMTMNU_FLAG_HALTED | EPL_NMTMNU_FLAG_APP_INFORMED)) == 0) {    // boot process is not halted
2484                 switch (NmtState) {
2485                 case kEplNmtMsPreOperational1:
2486                         {
2487                                 if ((EplNmtMnuInstance_g.m_uiSignalSlaveCount ==
2488                                      0)
2489                                     && (EplNmtMnuInstance_g.m_uiMandatorySlaveCount == 0)) {    // all optional CNs scanned once and all mandatory CNs configured successfully
2490                                         EplNmtMnuInstance_g.m_wFlags |=
2491                                             EPL_NMTMNU_FLAG_APP_INFORMED;
2492                                         // inform application
2493                                         Ret =
2494                                             EplNmtMnuInstance_g.
2495                                             m_pfnCbBootEvent
2496                                             (kEplNmtBootEventBootStep1Finish,
2497                                              NmtState, EPL_E_NO_ERROR);
2498                                         if (Ret != kEplSuccessful) {
2499                                                 if (Ret == kEplReject) {
2500                                                         // wait for application
2501                                                         Ret = kEplSuccessful;
2502                                                 }
2503                                                 break;
2504                                         }
2505                                         // enter PreOp2
2506                                         Ret =
2507                                             EplNmtuNmtEvent
2508                                             (kEplNmtEventAllMandatoryCNIdent);
2509                                 }
2510                                 break;
2511                         }
2512
2513                 case kEplNmtMsPreOperational2:
2514                         {
2515                                 if ((EplNmtMnuInstance_g.m_uiSignalSlaveCount ==
2516                                      0)
2517                                     && (EplNmtMnuInstance_g.m_uiMandatorySlaveCount == 0)) {    // all optional CNs checked once for ReadyToOp and all mandatory CNs are ReadyToOp
2518                                         EplNmtMnuInstance_g.m_wFlags |=
2519                                             EPL_NMTMNU_FLAG_APP_INFORMED;
2520                                         // inform application
2521                                         Ret =
2522                                             EplNmtMnuInstance_g.
2523                                             m_pfnCbBootEvent
2524                                             (kEplNmtBootEventBootStep2Finish,
2525                                              NmtState, EPL_E_NO_ERROR);
2526                                         if (Ret != kEplSuccessful) {
2527                                                 if (Ret == kEplReject) {
2528                                                         // wait for application
2529                                                         Ret = kEplSuccessful;
2530                                                 }
2531                                                 break;
2532                                         }
2533                                         // enter ReadyToOp
2534                                         Ret =
2535                                             EplNmtuNmtEvent
2536                                             (kEplNmtEventEnterReadyToOperate);
2537                                 }
2538                                 break;
2539                         }
2540
2541                 case kEplNmtMsReadyToOperate:
2542                         {
2543                                 if ((EplNmtMnuInstance_g.m_uiSignalSlaveCount ==
2544                                      0)
2545                                     && (EplNmtMnuInstance_g.m_uiMandatorySlaveCount == 0)) {    // all CNs checked for errorless communication
2546                                         EplNmtMnuInstance_g.m_wFlags |=
2547                                             EPL_NMTMNU_FLAG_APP_INFORMED;
2548                                         // inform application
2549                                         Ret =
2550                                             EplNmtMnuInstance_g.
2551                                             m_pfnCbBootEvent
2552                                             (kEplNmtBootEventCheckComFinish,
2553                                              NmtState, EPL_E_NO_ERROR);
2554                                         if (Ret != kEplSuccessful) {
2555                                                 if (Ret == kEplReject) {
2556                                                         // wait for application
2557                                                         Ret = kEplSuccessful;
2558                                                 }
2559                                                 break;
2560                                         }
2561                                         // enter Operational
2562                                         Ret =
2563                                             EplNmtuNmtEvent
2564                                             (kEplNmtEventEnterMsOperational);
2565                                 }
2566                                 break;
2567                         }
2568
2569                 case kEplNmtMsOperational:
2570                         {
2571                                 if ((EplNmtMnuInstance_g.m_uiSignalSlaveCount ==
2572                                      0)
2573                                     && (EplNmtMnuInstance_g.m_uiMandatorySlaveCount == 0)) {    // all optional CNs scanned once and all mandatory CNs are OPERATIONAL
2574                                         EplNmtMnuInstance_g.m_wFlags |=
2575                                             EPL_NMTMNU_FLAG_APP_INFORMED;
2576                                         // inform application
2577                                         Ret =
2578                                             EplNmtMnuInstance_g.
2579                                             m_pfnCbBootEvent
2580                                             (kEplNmtBootEventOperational,
2581                                              NmtState, EPL_E_NO_ERROR);
2582                                         if (Ret != kEplSuccessful) {
2583                                                 if (Ret == kEplReject) {
2584                                                         // ignore error code
2585                                                         Ret = kEplSuccessful;
2586                                                 }
2587                                                 break;
2588                                         }
2589                                 }
2590                                 break;
2591                         }
2592
2593                 default:
2594                         {
2595                                 break;
2596                         }
2597                 }
2598         }
2599
2600       Exit:
2601         return Ret;
2602 }
2603
2604 //---------------------------------------------------------------------------
2605 //
2606 // Function:    EplNmtMnuCheckNmtState
2607 //
2608 // Description: checks the NMT state, i.e. evaluates it with object 0x1F8F
2609 //              NMT_MNNodeExpState_AU8 and updates object 0x1F8E
2610 //              NMT_MNNodeCurrState_AU8.
2611 //              It manipulates m_NodeState in internal node info structure.
2612 //
2613 // Parameters:  uiNodeId_p              = node ID
2614 //              NodeNmtState_p          = NMT state of CN
2615 //
2616 // Returns:     tEplKernel              = error code
2617 //                  kEplReject          = CN was in wrong state and has been reset
2618 //
2619 // State:
2620 //
2621 //---------------------------------------------------------------------------
2622
2623 static tEplKernel EplNmtMnuCheckNmtState(unsigned int uiNodeId_p,
2624                                          tEplNmtMnuNodeInfo * pNodeInfo_p,
2625                                          tEplNmtState NodeNmtState_p,
2626                                          u16 wErrorCode_p,
2627                                          tEplNmtState LocalNmtState_p)
2628 {
2629         tEplKernel Ret = kEplSuccessful;
2630         tEplObdSize ObdSize;
2631         u8 bNmtState;
2632         u8 bNmtStatePrev;
2633         tEplNmtState ExpNmtState;
2634
2635         ObdSize = 1;
2636         // read object 0x1F8F NMT_MNNodeExpState_AU8
2637         Ret = EplObduReadEntry(0x1F8F, uiNodeId_p, &bNmtState, &ObdSize);
2638         if (Ret != kEplSuccessful) {
2639                 goto Exit;
2640         }
2641         // compute expected NMT state
2642         ExpNmtState = (tEplNmtState) (bNmtState | EPL_NMT_TYPE_CS);
2643         // compute u8 of current NMT state
2644         bNmtState = ((u8) NodeNmtState_p & 0xFF);
2645
2646         if (ExpNmtState == kEplNmtCsNotActive) {        // ignore the current state, because the CN shall be not active
2647                 Ret = kEplReject;
2648                 goto Exit;
2649         } else if ((ExpNmtState == kEplNmtCsPreOperational2)
2650                    && (NodeNmtState_p == kEplNmtCsReadyToOperate)) {    // CN switched to ReadyToOp
2651                 // delete timer for timeout handling
2652                 Ret = EplTimeruDeleteTimer(&pNodeInfo_p->m_TimerHdlLonger);
2653                 if (Ret != kEplSuccessful) {
2654                         goto Exit;
2655                 }
2656                 pNodeInfo_p->m_NodeState = kEplNmtMnuNodeStateReadyToOp;
2657
2658                 // update object 0x1F8F NMT_MNNodeExpState_AU8 to ReadyToOp
2659                 Ret = EplObduWriteEntry(0x1F8F, uiNodeId_p, &bNmtState, 1);
2660                 if (Ret != kEplSuccessful) {
2661                         goto Exit;
2662                 }
2663
2664                 if ((pNodeInfo_p->m_dwNodeCfg & EPL_NODEASSIGN_MANDATORY_CN) != 0) {    // node is a mandatory CN -> decrement counter
2665                         EplNmtMnuInstance_g.m_uiMandatorySlaveCount--;
2666                 }
2667                 if (LocalNmtState_p >= kEplNmtMsReadyToOperate) {       // start procedure CheckCommunication for this node
2668                         Ret = EplNmtMnuNodeCheckCom(uiNodeId_p, pNodeInfo_p);
2669                         if (Ret != kEplSuccessful) {
2670                                 goto Exit;
2671                         }
2672
2673                         if ((LocalNmtState_p == kEplNmtMsOperational)
2674                             && (pNodeInfo_p->m_NodeState ==
2675                                 kEplNmtMnuNodeStateComChecked)) {
2676                                 EPL_NMTMNU_DBG_POST_TRACE_VALUE(0, uiNodeId_p,
2677                                                                 (((NodeNmtState_p & 0xFF) << 8)
2678                                                                  |
2679                                                                  kEplNmtCmdStartNode));
2680
2681                                 // immediately start optional CN, because communication is always OK (e.g. async-only CN)
2682                                 Ret =
2683                                     EplNmtMnuSendNmtCommand(uiNodeId_p,
2684                                                             kEplNmtCmdStartNode);
2685                                 if (Ret != kEplSuccessful) {
2686                                         goto Exit;
2687                                 }
2688                         }
2689                 }
2690
2691         } else if ((ExpNmtState == kEplNmtCsReadyToOperate)
2692                    && (NodeNmtState_p == kEplNmtCsOperational)) {       // CN switched to OPERATIONAL
2693                 pNodeInfo_p->m_NodeState = kEplNmtMnuNodeStateOperational;
2694
2695                 if ((pNodeInfo_p->m_dwNodeCfg & EPL_NODEASSIGN_MANDATORY_CN) != 0) {    // node is a mandatory CN -> decrement counter
2696                         EplNmtMnuInstance_g.m_uiMandatorySlaveCount--;
2697                 }
2698
2699         } else if ((ExpNmtState != NodeNmtState_p)
2700                    && !((ExpNmtState == kEplNmtCsPreOperational1)
2701                         && (NodeNmtState_p == kEplNmtCsPreOperational2))) {     // CN is not in expected NMT state (without the exceptions above)
2702                 u16 wbeErrorCode;
2703
2704                 if ((pNodeInfo_p->
2705                      m_wFlags & EPL_NMTMNU_NODE_FLAG_NOT_SCANNED) != 0) {
2706                         // decrement only signal slave count if checked once
2707                         EplNmtMnuInstance_g.m_uiSignalSlaveCount--;
2708                         pNodeInfo_p->m_wFlags &=
2709                             ~EPL_NMTMNU_NODE_FLAG_NOT_SCANNED;
2710                 }
2711
2712                 if (pNodeInfo_p->m_NodeState == kEplNmtMnuNodeStateUnknown) {   // CN is already in state unknown, which means that it got
2713                         // NMT reset command earlier
2714                         goto Exit;
2715                 }
2716                 // -> CN is in wrong NMT state
2717                 pNodeInfo_p->m_NodeState = kEplNmtMnuNodeStateUnknown;
2718
2719                 if (wErrorCode_p == 0) {        // assume wrong NMT state error
2720                         if ((pNodeInfo_p->m_wFlags & EPL_NMTMNU_NODE_FLAG_NMT_CMD_ISSUED) != 0) {       // NMT command has been just issued;
2721                                 // ignore wrong NMT state until timer expires;
2722                                 // other errors like LOSS_PRES_TH are still processed
2723                                 goto Exit;
2724                         }
2725
2726                         wErrorCode_p = EPL_E_NMT_WRONG_STATE;
2727                 }
2728
2729                 BENCHMARK_MOD_07_TOGGLE(9);
2730
2731                 // $$$ start ERROR_TREATMENT and inform application
2732                 Ret = EplNmtMnuInstance_g.m_pfnCbNodeEvent(uiNodeId_p,
2733                                                            kEplNmtNodeEventError,
2734                                                            NodeNmtState_p,
2735                                                            wErrorCode_p,
2736                                                            (pNodeInfo_p->
2737                                                             m_dwNodeCfg &
2738                                                             EPL_NODEASSIGN_MANDATORY_CN)
2739                                                            != 0);
2740                 if (Ret != kEplSuccessful) {
2741                         goto Exit;
2742                 }
2743
2744                 EPL_NMTMNU_DBG_POST_TRACE_VALUE(0,
2745                                                 uiNodeId_p,
2746                                                 (((NodeNmtState_p & 0xFF) << 8)
2747                                                  | kEplNmtCmdResetNode));
2748
2749                 // reset CN
2750                 // store error code in NMT command data for diagnostic purpose
2751                 AmiSetWordToLe(&wbeErrorCode, wErrorCode_p);
2752                 Ret =
2753                     EplNmtMnuSendNmtCommandEx(uiNodeId_p, kEplNmtCmdResetNode,
2754                                               &wbeErrorCode,
2755                                               sizeof(wbeErrorCode));
2756                 if (Ret == kEplSuccessful) {
2757                         Ret = kEplReject;
2758                 }
2759
2760                 goto Exit;
2761         }
2762         // check if NMT_MNNodeCurrState_AU8 has to be changed
2763         ObdSize = 1;
2764         Ret = EplObduReadEntry(0x1F8E, uiNodeId_p, &bNmtStatePrev, &ObdSize);
2765         if (Ret != kEplSuccessful) {
2766                 goto Exit;
2767         }
2768         if (bNmtState != bNmtStatePrev) {
2769                 // update object 0x1F8E NMT_MNNodeCurrState_AU8
2770                 Ret = EplObduWriteEntry(0x1F8E, uiNodeId_p, &bNmtState, 1);
2771                 if (Ret != kEplSuccessful) {
2772                         goto Exit;
2773                 }
2774                 Ret = EplNmtMnuInstance_g.m_pfnCbNodeEvent(uiNodeId_p,
2775                                                            kEplNmtNodeEventNmtState,
2776                                                            NodeNmtState_p,
2777                                                            wErrorCode_p,
2778                                                            (pNodeInfo_p->
2779                                                             m_dwNodeCfg &
2780                                                             EPL_NODEASSIGN_MANDATORY_CN)
2781                                                            != 0);
2782                 if (Ret != kEplSuccessful) {
2783                         goto Exit;
2784                 }
2785         }
2786
2787       Exit:
2788         return Ret;
2789 }
2790
2791 //---------------------------------------------------------------------------
2792 //
2793 // Function:    EplNmtMnuReset
2794 //
2795 // Description: reset internal structures, e.g. timers
2796 //
2797 // Parameters:  void
2798 //
2799 // Returns:     tEplKernel              = error code
2800 //
2801 // State:
2802 //
2803 //---------------------------------------------------------------------------
2804
2805 static tEplKernel EplNmtMnuReset(void)
2806 {
2807         tEplKernel Ret;
2808         int iIndex;
2809
2810         Ret = EplTimeruDeleteTimer(&EplNmtMnuInstance_g.m_TimerHdlNmtState);
2811
2812         for (iIndex = 1; iIndex <= tabentries(EplNmtMnuInstance_g.m_aNodeInfo);
2813              iIndex++) {
2814                 // delete timer handles
2815                 Ret =
2816                     EplTimeruDeleteTimer(&EPL_NMTMNU_GET_NODEINFO(iIndex)->
2817                                          m_TimerHdlStatReq);
2818                 Ret =
2819                     EplTimeruDeleteTimer(&EPL_NMTMNU_GET_NODEINFO(iIndex)->
2820                                          m_TimerHdlLonger);
2821         }
2822
2823         return Ret;
2824 }
2825
2826 #endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
2827
2828 // EOF