drivers/staging/epl/EplDllk.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 kernel DLL 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: EplDllk.c,v $
  53
  54                 $Author: D.Krueger $
  55
  56                 $Revision: 1.21 $  $Date: 2008/11/13 17:13:09 $
  57
  58                 $State: Exp $
  59
  60                 Build Environment:
  61                     GCC V3.4
  62
  63   -------------------------------------------------------------------------
  64
  65   Revision History:
  66
  67   2006/06/12 d.k.:   start of the implementation, version 1.00
  68
  69 ****************************************************************************/
  70
  71 #include "kernel/EplDllk.h"
  72 #include "kernel/EplDllkCal.h"
  73 #include "kernel/EplEventk.h"
  74 #include "kernel/EplNmtk.h"
  75 #include "edrv.h"
  76 #include "Benchmark.h"
  77
  78 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
  79 #include "kernel/EplPdok.h"
  80 #endif
  81
  82 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_VETH)) != 0)
  83 #include "kernel/VirtualEthernet.h"
  84 #endif
  85
  86 //#if EPL_TIMER_USE_HIGHRES != FALSE
  87 #include "kernel/EplTimerHighResk.h"
  88 //#endif
  89
  90 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
  91
  92 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) == 0)
  93 #error "EPL module DLLK needs EPL module NMTK!"
  94 #endif
  95
  96 #if (EPL_DLL_PRES_READY_AFTER_SOA != FALSE) && (EPL_DLL_PRES_READY_AFTER_SOC != FALSE)
  97 #error "EPL module DLLK: select only one of EPL_DLL_PRES_READY_AFTER_SOA and EPL_DLL_PRES_READY_AFTER_SOC."
  98 #endif
  99
 100 #if ((EPL_DLL_PRES_READY_AFTER_SOA != FALSE) || (EPL_DLL_PRES_READY_AFTER_SOC != FALSE)) \
 101     && (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) == 0)
 102 #error "EPL module DLLK: currently, EPL_DLL_PRES_READY_AFTER_* is not supported if EPL_MODULE_NMT_MN is enabled."
 103 #endif
 104
 105 #if (EDRV_FAST_TXFRAMES == FALSE) && \
 106     ((EPL_DLL_PRES_READY_AFTER_SOA != FALSE) || (EPL_DLL_PRES_READY_AFTER_SOC != FALSE))
 107 #error "EPL module DLLK: EPL_DLL_PRES_READY_AFTER_* is enabled, but not EDRV_FAST_TXFRAMES."
 108 #endif
 109
 110 /***************************************************************************/
 111 /*                                                                         */
 112 /*                                                                         */
 113 /*          G L O B A L   D E F I N I T I O N S                            */
 114 /*                                                                         */
 115 /*                                                                         */
 116 /***************************************************************************/
 117
 118 //---------------------------------------------------------------------------
 119 // const defines
 120 //---------------------------------------------------------------------------
 121
 122 // TracePoint support for realtime-debugging
 123 #ifdef _DBG_TRACE_POINTS_
 124 void TgtDbgSignalTracePoint(u8 bTracePointNumber_p);
 125 void TgtDbgPostTraceValue(u32 dwTraceValue_p);
 126 #define TGT_DBG_SIGNAL_TRACE_POINT(p)   TgtDbgSignalTracePoint(p)
 127 #define TGT_DBG_POST_TRACE_VALUE(v)     TgtDbgPostTraceValue(v)
 128 #else
 129 #define TGT_DBG_SIGNAL_TRACE_POINT(p)
 130 #define TGT_DBG_POST_TRACE_VALUE(v)
 131 #endif
 132 #define EPL_DLLK_DBG_POST_TRACE_VALUE(Event_p, uiNodeId_p, wErrorCode_p) \
 133     TGT_DBG_POST_TRACE_VALUE((kEplEventSinkDllk << 28) | (Event_p << 24) \
 134                              | (uiNodeId_p << 16) | wErrorCode_p)
 135
 136 /***************************************************************************/
 137 /*                                                                         */
 138 /*                                                                         */
 139 /*          C L A S S  EplDllk                                             */
 140 /*                                                                         */
 141 /*                                                                         */
 142 /***************************************************************************/
 143 //
 144 // Description:
 145 //
 146 //
 147 /***************************************************************************/
 148
 149 //=========================================================================//
 150 //                                                                         //
 151 //          P R I V A T E   D E F I N I T I O N S                          //
 152 //                                                                         //
 153 //=========================================================================//
 154
 155 //---------------------------------------------------------------------------
 156 // const defines
 157 //---------------------------------------------------------------------------
 158
 159 // defines for indexes of tEplDllInstance.m_pTxFrameInfo
 160 #define EPL_DLLK_TXFRAME_IDENTRES   0   // IdentResponse on CN / MN
 161 #define EPL_DLLK_TXFRAME_STATUSRES  1   // StatusResponse on CN / MN
 162 #define EPL_DLLK_TXFRAME_NMTREQ     2   // NMT Request from FIFO on CN / MN
 163 #define EPL_DLLK_TXFRAME_NONEPL     3   // non-EPL frame from FIFO on CN / MN
 164 #define EPL_DLLK_TXFRAME_PRES       4   // PRes on CN / MN
 165 #define EPL_DLLK_TXFRAME_SOC        5   // SoC on MN
 166 #define EPL_DLLK_TXFRAME_SOA        6   // SoA on MN
 167 #define EPL_DLLK_TXFRAME_PREQ       7   // PReq on MN
 168 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
 169 #define EPL_DLLK_TXFRAME_COUNT      (7 + EPL_D_NMT_MaxCNNumber_U8 + 2)  // on MN: 7 + MaxPReq of regular CNs + 1 Diag + 1 Router
 170 #else
 171 #define EPL_DLLK_TXFRAME_COUNT      5   // on CN: 5
 172 #endif
 173
 174 #define EPL_DLLK_BUFLEN_EMPTY       0   // buffer is empty
 175 #define EPL_DLLK_BUFLEN_FILLING     1   // just the buffer is being filled
 176 #define EPL_DLLK_BUFLEN_MIN         60  // minimum ethernet frame length
 177
 178 //---------------------------------------------------------------------------
 179 // local types
 180 //---------------------------------------------------------------------------
 181
 182 typedef enum {
 183         kEplDllGsInit = 0x00,   // MN/CN: initialisation (< PreOp2)
 184         kEplDllCsWaitPreq = 0x01,       // CN: wait for PReq frame
 185         kEplDllCsWaitSoc = 0x02,        // CN: wait for SoC frame
 186         kEplDllCsWaitSoa = 0x03,        // CN: wait for SoA frame
 187         kEplDllMsNonCyclic = 0x04,      // MN: reduced EPL cycle (PreOp1)
 188         kEplDllMsWaitSocTrig = 0x05,    // MN: wait for SoC trigger (cycle timer)
 189         kEplDllMsWaitPreqTrig = 0x06,   // MN: wait for (first) PReq trigger (WaitSoCPReq_U32)
 190         kEplDllMsWaitPres = 0x07,       // MN: wait for PRes frame from CN
 191         kEplDllMsWaitSoaTrig = 0x08,    // MN: wait for SoA trigger (PRes transmitted)
 192         kEplDllMsWaitAsndTrig = 0x09,   // MN: wait for ASnd trigger (SoA transmitted)
 193         kEplDllMsWaitAsnd = 0x0A,       // MN: wait for ASnd frame if SoA contained invitation
 194
 195 } tEplDllState;
 196
 197 typedef struct {
 198         u8 m_be_abSrcMac[6];
 199         tEdrvTxBuffer *m_pTxBuffer;     // Buffers for Tx-Frames
 200         unsigned int m_uiMaxTxFrames;
 201         u8 m_bFlag1;            // Flag 1 with EN, EC for PRes, StatusRes
 202         u8 m_bMnFlag1;  // Flag 1 with EA, ER from PReq, SoA of MN
 203         u8 m_bFlag2;            // Flag 2 with PR and RS for PRes, StatusRes, IdentRes
 204         tEplDllConfigParam m_DllConfigParam;
 205         tEplDllIdentParam m_DllIdentParam;
 206         tEplDllState m_DllState;
 207         tEplDllkCbAsync m_pfnCbAsync;
 208         tEplDllAsndFilter m_aAsndFilter[EPL_DLL_MAX_ASND_SERVICE_ID];
 209
 210 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
 211         tEplDllkNodeInfo *m_pFirstNodeInfo;
 212         tEplDllkNodeInfo *m_pCurNodeInfo;
 213         tEplDllkNodeInfo m_aNodeInfo[EPL_NMT_MAX_NODE_ID];
 214         tEplDllReqServiceId m_LastReqServiceId;
 215         unsigned int m_uiLastTargetNodeId;
 216 #endif
 217
 218 #if EPL_TIMER_USE_HIGHRES != FALSE
 219         tEplTimerHdl m_TimerHdlCycle;   // used for EPL cycle monitoring on CN and generation on MN
 220 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
 221         tEplTimerHdl m_TimerHdlResponse;        // used for CN response monitoring
 222 #endif                          //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
 223 #endif
 224
 225         unsigned int m_uiCycleCount;    // cycle counter (needed for multiplexed cycle support)
 226         unsigned long long m_ullFrameTimeout;   // frame timeout (cycle length + loss of frame tolerance)
 227
 228 } tEplDllkInstance;
 229
 230 //---------------------------------------------------------------------------
 231 // local vars
 232 //---------------------------------------------------------------------------
 233
 234 // if no dynamic memory allocation shall be used
 235 // define structures statically
 236 static tEplDllkInstance EplDllkInstance_g;
 237
 238 static tEdrvTxBuffer aEplDllkTxBuffer_l[EPL_DLLK_TXFRAME_COUNT];
 239
 240 //---------------------------------------------------------------------------
 241 // local function prototypes
 242 //---------------------------------------------------------------------------
 243
 244 // change DLL state on event
 245 static tEplKernel EplDllkChangeState(tEplNmtEvent NmtEvent_p,
 246                                      tEplNmtState NmtState_p);
 247
 248 // called from EdrvInterruptHandler()
 249 static void EplDllkCbFrameReceived(tEdrvRxBuffer * pRxBuffer_p);
 250
 251 // called from EdrvInterruptHandler()
 252 static void EplDllkCbFrameTransmitted(tEdrvTxBuffer * pTxBuffer_p);
 253
 254 // check frame and set missing information
 255 static tEplKernel EplDllkCheckFrame(tEplFrame * pFrame_p,
 256                                     unsigned int uiFrameSize_p);
 257
 258 // called by high resolution timer module to monitor EPL cycle as CN
 259 #if EPL_TIMER_USE_HIGHRES != FALSE
 260 static tEplKernel EplDllkCbCnTimer(tEplTimerEventArg *pEventArg_p);
 261 #endif
 262
 263 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
 264 // MN: returns internal node info structure
 265 static tEplDllkNodeInfo *EplDllkGetNodeInfo(unsigned int uiNodeId_p);
 266
 267 // transmit SoA
 268 static tEplKernel EplDllkMnSendSoa(tEplNmtState NmtState_p,
 269                                    tEplDllState * pDllStateProposed_p,
 270                                    BOOL fEnableInvitation_p);
 271
 272 static tEplKernel EplDllkMnSendSoc(void);
 273
 274 static tEplKernel EplDllkMnSendPreq(tEplNmtState NmtState_p,
 275                                     tEplDllState * pDllStateProposed_p);
 276
 277 static tEplKernel EplDllkAsyncFrameNotReceived(tEplDllReqServiceId
 278                                                ReqServiceId_p,
 279                                                unsigned int uiNodeId_p);
 280
 281 static tEplKernel EplDllkCbMnTimerCycle(tEplTimerEventArg *pEventArg_p);
 282
 283 static tEplKernel EplDllkCbMnTimerResponse(tEplTimerEventArg *pEventArg_p);
 284
 285 #endif
 286
 287 //=========================================================================//
 288 //                                                                         //
 289 //          P U B L I C   F U N C T I O N S                                //
 290 //                                                                         //
 291 //=========================================================================//
 292
 293 //---------------------------------------------------------------------------
 294 //
 295 // Function:    EplDllkAddInstance()
 296 //
 297 // Description: add and initialize new instance of EPL stack
 298 //
 299 // Parameters:  pInitParam_p            = initialisation parameters like MAC address
 300 //
 301 // Returns:     tEplKernel              = error code
 302 //
 303 //
 304 // State:
 305 //
 306 //---------------------------------------------------------------------------
 307
 308 tEplKernel EplDllkAddInstance(tEplDllkInitParam * pInitParam_p)
 309 {
 310         tEplKernel Ret = kEplSuccessful;
 311         unsigned int uiIndex;
 312         tEdrvInitParam EdrvInitParam;
 313
 314         // reset instance structure
 315         EPL_MEMSET(&EplDllkInstance_g, 0, sizeof(EplDllkInstance_g));
 316
 317 #if EPL_TIMER_USE_HIGHRES != FALSE
 318         Ret = EplTimerHighReskInit();
 319         if (Ret != kEplSuccessful) {    // error occured while initializing high resolution timer module
 320                 goto Exit;
 321         }
 322 #endif
 323
 324         // if dynamic memory allocation available
 325         // allocate instance structure
 326         // allocate TPDO and RPDO table with default size
 327
 328         // initialize and link pointers in instance structure to frame tables
 329         EplDllkInstance_g.m_pTxBuffer = aEplDllkTxBuffer_l;
 330         EplDllkInstance_g.m_uiMaxTxFrames =
 331             sizeof(aEplDllkTxBuffer_l) / sizeof(tEdrvTxBuffer);
 332
 333         // initialize state
 334         EplDllkInstance_g.m_DllState = kEplDllGsInit;
 335
 336 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
 337         // set up node info structure
 338         for (uiIndex = 0; uiIndex < tabentries(EplDllkInstance_g.m_aNodeInfo);
 339              uiIndex++) {
 340                 EplDllkInstance_g.m_aNodeInfo[uiIndex].m_uiNodeId = uiIndex + 1;
 341                 EplDllkInstance_g.m_aNodeInfo[uiIndex].m_wPresPayloadLimit =
 342                     0xFFFF;
 343         }
 344 #endif
 345
 346         // initialize Edrv
 347         EPL_MEMCPY(EdrvInitParam.m_abMyMacAddr, pInitParam_p->m_be_abSrcMac, 6);
 348         EdrvInitParam.m_pfnRxHandler = EplDllkCbFrameReceived;
 349         EdrvInitParam.m_pfnTxHandler = EplDllkCbFrameTransmitted;
 350         Ret = EdrvInit(&EdrvInitParam);
 351         if (Ret != kEplSuccessful) {    // error occured while initializing ethernet driver
 352                 goto Exit;
 353         }
 354         // copy local MAC address from Ethernet driver back to local instance structure
 355         // because Ethernet driver may have read it from controller EEPROM
 356         EPL_MEMCPY(EplDllkInstance_g.m_be_abSrcMac, EdrvInitParam.m_abMyMacAddr,
 357                    6);
 358         EPL_MEMCPY(pInitParam_p->m_be_abSrcMac, EdrvInitParam.m_abMyMacAddr, 6);
 359
 360         // initialize TxBuffer array
 361         for (uiIndex = 0; uiIndex < EplDllkInstance_g.m_uiMaxTxFrames;
 362              uiIndex++) {
 363                 EplDllkInstance_g.m_pTxBuffer[uiIndex].m_pbBuffer = NULL;
 364         }
 365
 366 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_VETH)) != 0)
 367         Ret = VEthAddInstance(pInitParam_p);
 368 #endif
 369
 370       Exit:
 371         return Ret;
 372 }
 373
 374 //---------------------------------------------------------------------------
 375 //
 376 // Function:    EplDllkDelInstance()
 377 //
 378 // Description: deletes an instance of EPL stack
 379 //
 380 // Parameters:  (none)
 381 //
 382 // Returns:     tEplKernel              = error code
 383 //
 384 //
 385 // State:
 386 //
 387 //---------------------------------------------------------------------------
 388
 389 tEplKernel EplDllkDelInstance(void)
 390 {
 391         tEplKernel Ret = kEplSuccessful;
 392
 393         // reset state
 394         EplDllkInstance_g.m_DllState = kEplDllGsInit;
 395
 396 #if EPL_TIMER_USE_HIGHRES != FALSE
 397         Ret = EplTimerHighReskDelInstance();
 398 #endif
 399
 400 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_VETH)) != 0)
 401         Ret = VEthDelInstance();
 402 #endif
 403
 404         Ret = EdrvShutdown();
 405         return Ret;
 406 }
 407
 408 //---------------------------------------------------------------------------
 409 //
 410 // Function:    EplDllkCreateTxFrame
 411 //
 412 // Description: creates the buffer for a Tx frame and registers it to the
 413 //              ethernet driver
 414 //
 415 // Parameters:  puiHandle_p             = OUT: handle to frame buffer
 416 //              ppFrame_p               = OUT: pointer to pointer of EPL frame
 417 //              puiFrameSize_p          = IN/OUT: pointer to size of frame
 418 //                                        returned size is always equal or larger than
 419 //                                        requested size, if that is not possible
 420 //                                        an error will be returned
 421 //              MsgType_p               = EPL message type
 422 //              ServiceId_p             = Service ID in case of ASnd frame, otherwise
 423 //                                        kEplDllAsndNotDefined
 424 //
 425 // Returns:     tEplKernel              = error code
 426 //
 427 //
 428 // State:
 429 //
 430 //---------------------------------------------------------------------------
 431
 432 tEplKernel EplDllkCreateTxFrame(unsigned int *puiHandle_p,
 433                                 tEplFrame ** ppFrame_p,
 434                                 unsigned int *puiFrameSize_p,
 435                                 tEplMsgType MsgType_p,
 436                                 tEplDllAsndServiceId ServiceId_p)
 437 {
 438         tEplKernel Ret = kEplSuccessful;
 439         tEplFrame *pTxFrame;
 440         unsigned int uiHandle = EplDllkInstance_g.m_uiMaxTxFrames;
 441         tEdrvTxBuffer *pTxBuffer = NULL;
 442
 443         if (MsgType_p == kEplMsgTypeAsnd) {
 444                 // search for fixed Tx buffers
 445                 if (ServiceId_p == kEplDllAsndIdentResponse) {
 446                         uiHandle = EPL_DLLK_TXFRAME_IDENTRES;
 447                 } else if (ServiceId_p == kEplDllAsndStatusResponse) {
 448                         uiHandle = EPL_DLLK_TXFRAME_STATUSRES;
 449                 } else if ((ServiceId_p == kEplDllAsndNmtRequest)
 450                            || (ServiceId_p == kEplDllAsndNmtCommand)) {
 451                         uiHandle = EPL_DLLK_TXFRAME_NMTREQ;
 452                 }
 453
 454                 if (uiHandle >= EplDllkInstance_g.m_uiMaxTxFrames) {    // look for free entry
 455                         uiHandle = EPL_DLLK_TXFRAME_PREQ;
 456                         pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[uiHandle];
 457                         for (; uiHandle < EplDllkInstance_g.m_uiMaxTxFrames;
 458                              uiHandle++, pTxBuffer++) {
 459                                 if (pTxBuffer->m_pbBuffer == NULL) {    // free entry found
 460                                         break;
 461                                 }
 462                         }
 463                 }
 464         } else if (MsgType_p == kEplMsgTypeNonEpl) {
 465                 uiHandle = EPL_DLLK_TXFRAME_NONEPL;
 466         } else if (MsgType_p == kEplMsgTypePres) {
 467                 uiHandle = EPL_DLLK_TXFRAME_PRES;
 468         } else if (MsgType_p == kEplMsgTypeSoc) {
 469                 uiHandle = EPL_DLLK_TXFRAME_SOC;
 470         } else if (MsgType_p == kEplMsgTypeSoa) {
 471                 uiHandle = EPL_DLLK_TXFRAME_SOA;
 472         } else {                // look for free entry
 473                 uiHandle = EPL_DLLK_TXFRAME_PREQ;
 474                 pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[uiHandle];
 475                 for (; uiHandle < EplDllkInstance_g.m_uiMaxTxFrames;
 476                      uiHandle++, pTxBuffer++) {
 477                         if (pTxBuffer->m_pbBuffer == NULL) {    // free entry found
 478                                 break;
 479                         }
 480                 }
 481                 if (pTxBuffer->m_pbBuffer != NULL) {
 482                         Ret = kEplEdrvNoFreeBufEntry;
 483                         goto Exit;
 484                 }
 485         }
 486
 487         // test if requested entry is free
 488         pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[uiHandle];
 489         if (pTxBuffer->m_pbBuffer != NULL) {    // entry is not free
 490                 Ret = kEplEdrvNoFreeBufEntry;
 491                 goto Exit;
 492         }
 493         // setup Tx buffer
 494         pTxBuffer->m_EplMsgType = MsgType_p;
 495         pTxBuffer->m_uiMaxBufferLen = *puiFrameSize_p;
 496
 497         Ret = EdrvAllocTxMsgBuffer(pTxBuffer);
 498         if (Ret != kEplSuccessful) {    // error occured while registering Tx frame
 499                 goto Exit;
 500         }
 501         // because buffer size may be larger than requested
 502         // memorize real length of frame
 503         pTxBuffer->m_uiTxMsgLen = *puiFrameSize_p;
 504
 505         // fill whole frame with 0
 506         EPL_MEMSET(pTxBuffer->m_pbBuffer, 0, pTxBuffer->m_uiMaxBufferLen);
 507
 508         pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
 509
 510         if (MsgType_p != kEplMsgTypeNonEpl) {   // fill out Frame only if it is an EPL frame
 511                 // ethertype
 512                 AmiSetWordToBe(&pTxFrame->m_be_wEtherType,
 513                                EPL_C_DLL_ETHERTYPE_EPL);
 514                 // source node ID
 515                 AmiSetByteToLe(&pTxFrame->m_le_bSrcNodeId,
 516                                (u8) EplDllkInstance_g.m_DllConfigParam.
 517                                m_uiNodeId);
 518                 // source MAC address
 519                 EPL_MEMCPY(&pTxFrame->m_be_abSrcMac[0],
 520                            &EplDllkInstance_g.m_be_abSrcMac[0], 6);
 521                 switch (MsgType_p) {
 522                 case kEplMsgTypeAsnd:
 523                         // destination MAC address
 524                         AmiSetQword48ToBe(&pTxFrame->m_be_abDstMac[0],
 525                                           EPL_C_DLL_MULTICAST_ASND);
 526                         // destination node ID
 527                         switch (ServiceId_p) {
 528                         case kEplDllAsndIdentResponse:
 529                         case kEplDllAsndStatusResponse:
 530                                 {       // IdentResponses and StatusResponses are Broadcast
 531                                         AmiSetByteToLe(&pTxFrame->
 532                                                        m_le_bDstNodeId,
 533                                                        (u8)
 534                                                        EPL_C_ADR_BROADCAST);
 535                                         break;
 536                                 }
 537
 538                         default:
 539                                 break;
 540                         }
 541                         // ASnd Service ID
 542                         AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.m_le_bServiceId,
 543                                        ServiceId_p);
 544                         break;
 545
 546                 case kEplMsgTypeSoc:
 547                         // destination MAC address
 548                         AmiSetQword48ToBe(&pTxFrame->m_be_abDstMac[0],
 549                                           EPL_C_DLL_MULTICAST_SOC);
 550                         // destination node ID
 551                         AmiSetByteToLe(&pTxFrame->m_le_bDstNodeId,
 552                                        (u8) EPL_C_ADR_BROADCAST);
 553                         // reset Flags
 554                         //AmiSetByteToLe(&pTxFrame->m_Data.m_Soc.m_le_bFlag1, (u8) 0);
 555                         //AmiSetByteToLe(&pTxFrame->m_Data.m_Soc.m_le_bFlag2, (u8) 0);
 556                         break;
 557
 558                 case kEplMsgTypeSoa:
 559                         // destination MAC address
 560                         AmiSetQword48ToBe(&pTxFrame->m_be_abDstMac[0],
 561                                           EPL_C_DLL_MULTICAST_SOA);
 562                         // destination node ID
 563                         AmiSetByteToLe(&pTxFrame->m_le_bDstNodeId,
 564                                        (u8) EPL_C_ADR_BROADCAST);
 565                         // reset Flags
 566                         //AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.m_le_bFlag1, (u8) 0);
 567                         //AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.m_le_bFlag2, (u8) 0);
 568                         // EPL profile version
 569                         AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.m_le_bEplVersion,
 570                                        (u8) EPL_SPEC_VERSION);
 571                         break;
 572
 573                 case kEplMsgTypePres:
 574                         // destination MAC address
 575                         AmiSetQword48ToBe(&pTxFrame->m_be_abDstMac[0],
 576                                           EPL_C_DLL_MULTICAST_PRES);
 577                         // destination node ID
 578                         AmiSetByteToLe(&pTxFrame->m_le_bDstNodeId,
 579                                        (u8) EPL_C_ADR_BROADCAST);
 580                         // reset Flags
 581                         //AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bFlag1, (u8) 0);
 582                         //AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bFlag2, (u8) 0);
 583                         // PDO size
 584                         //AmiSetWordToLe(&pTxFrame->m_Data.m_Pres.m_le_wSize, 0);
 585                         break;
 586
 587                 case kEplMsgTypePreq:
 588                         // reset Flags
 589                         //AmiSetByteToLe(&pTxFrame->m_Data.m_Preq.m_le_bFlag1, (u8) 0);
 590                         //AmiSetByteToLe(&pTxFrame->m_Data.m_Preq.m_le_bFlag2, (u8) 0);
 591                         // PDO size
 592                         //AmiSetWordToLe(&pTxFrame->m_Data.m_Preq.m_le_wSize, 0);
 593                         break;
 594
 595                 default:
 596                         break;
 597                 }
 598                 // EPL message type
 599                 AmiSetByteToLe(&pTxFrame->m_le_bMessageType, (u8) MsgType_p);
 600         }
 601
 602         *ppFrame_p = pTxFrame;
 603         *puiFrameSize_p = pTxBuffer->m_uiMaxBufferLen;
 604         *puiHandle_p = uiHandle;
 605
 606       Exit:
 607         return Ret;
 608 }
 609
 610 //---------------------------------------------------------------------------
 611 //
 612 // Function:    EplDllkDeleteTxFrame
 613 //
 614 // Description: deletes the buffer for a Tx frame and frees it in the
 615 //              ethernet driver
 616 //
 617 // Parameters:  uiHandle_p              = IN: handle to frame buffer
 618 //
 619 // Returns:     tEplKernel              = error code
 620 //
 621 //
 622 // State:
 623 //
 624 //---------------------------------------------------------------------------
 625
 626 tEplKernel EplDllkDeleteTxFrame(unsigned int uiHandle_p)
 627 {
 628         tEplKernel Ret = kEplSuccessful;
 629         tEdrvTxBuffer *pTxBuffer = NULL;
 630
 631         if (uiHandle_p >= EplDllkInstance_g.m_uiMaxTxFrames) {  // handle is not valid
 632                 Ret = kEplDllIllegalHdl;
 633                 goto Exit;
 634         }
 635
 636         pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[uiHandle_p];
 637
 638         // mark buffer as free so that frame will not be send in future anymore
 639         // $$$ d.k. What's up with running transmissions?
 640         pTxBuffer->m_uiTxMsgLen = EPL_DLLK_BUFLEN_EMPTY;
 641         pTxBuffer->m_pbBuffer = NULL;
 642
 643         // delete Tx buffer
 644         Ret = EdrvReleaseTxMsgBuffer(pTxBuffer);
 645         if (Ret != kEplSuccessful) {    // error occured while releasing Tx frame
 646                 goto Exit;
 647         }
 648
 649       Exit:
 650         return Ret;
 651 }
 652
 653 //---------------------------------------------------------------------------
 654 //
 655 // Function:    EplDllkProcess
 656 //
 657 // Description: process the passed event
 658 //
 659 // Parameters:  pEvent_p                = event to be processed
 660 //
 661 // Returns:     tEplKernel              = error code
 662 //
 663 //
 664 // State:
 665 //
 666 //---------------------------------------------------------------------------
 667
 668 tEplKernel EplDllkProcess(tEplEvent * pEvent_p)
 669 {
 670         tEplKernel Ret = kEplSuccessful;
 671         tEplFrame *pTxFrame;
 672         tEdrvTxBuffer *pTxBuffer;
 673         unsigned int uiHandle;
 674         unsigned int uiFrameSize;
 675         u8 abMulticastMac[6];
 676         tEplDllAsyncReqPriority AsyncReqPriority;
 677         unsigned int uiFrameCount;
 678         tEplNmtState NmtState;
 679 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
 680         tEplFrameInfo FrameInfo;
 681 #endif
 682
 683         switch (pEvent_p->m_EventType) {
 684         case kEplEventTypeDllkCreate:
 685                 {
 686                         // $$$ reset ethernet driver
 687
 688                         NmtState = *((tEplNmtState *) pEvent_p->m_pArg);
 689
 690                         // initialize flags for PRes and StatusRes
 691                         EplDllkInstance_g.m_bFlag1 = EPL_FRAME_FLAG1_EC;
 692                         EplDllkInstance_g.m_bMnFlag1 = 0;
 693                         EplDllkInstance_g.m_bFlag2 = 0;
 694
 695 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
 696                         // initialize linked node list
 697                         EplDllkInstance_g.m_pFirstNodeInfo = NULL;
 698 #endif
 699
 700                         // register TxFrames in Edrv
 701
 702                         // IdentResponse
 703                         uiFrameSize = EPL_C_DLL_MINSIZE_IDENTRES;
 704                         Ret =
 705                             EplDllkCreateTxFrame(&uiHandle, &pTxFrame,
 706                                                  &uiFrameSize, kEplMsgTypeAsnd,
 707                                                  kEplDllAsndIdentResponse);
 708                         if (Ret != kEplSuccessful) {    // error occured while registering Tx frame
 709                                 goto Exit;
 710                         }
 711                         // EPL profile version
 712                         AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 713                                        m_IdentResponse.m_le_bEplProfileVersion,
 714                                        (u8) EPL_SPEC_VERSION);
 715                         // FeatureFlags
 716                         AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 717                                         m_IdentResponse.m_le_dwFeatureFlags,
 718                                         EplDllkInstance_g.m_DllConfigParam.
 719                                         m_dwFeatureFlags);
 720                         // MTU
 721                         AmiSetWordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 722                                        m_IdentResponse.m_le_wMtu,
 723                                        (u16) EplDllkInstance_g.
 724                                        m_DllConfigParam.m_uiAsyncMtu);
 725                         // PollInSize
 726                         AmiSetWordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 727                                        m_IdentResponse.m_le_wPollInSize,
 728                                        (u16) EplDllkInstance_g.
 729                                        m_DllConfigParam.
 730                                        m_uiPreqActPayloadLimit);
 731                         // PollOutSize
 732                         AmiSetWordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 733                                        m_IdentResponse.m_le_wPollOutSize,
 734                                        (u16) EplDllkInstance_g.
 735                                        m_DllConfigParam.
 736                                        m_uiPresActPayloadLimit);
 737                         // ResponseTime / PresMaxLatency
 738                         AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 739                                         m_IdentResponse.m_le_dwResponseTime,
 740                                         EplDllkInstance_g.m_DllConfigParam.
 741                                         m_dwPresMaxLatency);
 742                         // DeviceType
 743                         AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 744                                         m_IdentResponse.m_le_dwDeviceType,
 745                                         EplDllkInstance_g.m_DllIdentParam.
 746                                         m_dwDeviceType);
 747                         // VendorId
 748                         AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 749                                         m_IdentResponse.m_le_dwVendorId,
 750                                         EplDllkInstance_g.m_DllIdentParam.
 751                                         m_dwVendorId);
 752                         // ProductCode
 753                         AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 754                                         m_IdentResponse.m_le_dwProductCode,
 755                                         EplDllkInstance_g.m_DllIdentParam.
 756                                         m_dwProductCode);
 757                         // RevisionNumber
 758                         AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 759                                         m_IdentResponse.m_le_dwRevisionNumber,
 760                                         EplDllkInstance_g.m_DllIdentParam.
 761                                         m_dwRevisionNumber);
 762                         // SerialNumber
 763                         AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 764                                         m_IdentResponse.m_le_dwSerialNumber,
 765                                         EplDllkInstance_g.m_DllIdentParam.
 766                                         m_dwSerialNumber);
 767                         // VendorSpecificExt1
 768                         AmiSetQword64ToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 769                                           m_IdentResponse.
 770                                           m_le_qwVendorSpecificExt1,
 771                                           EplDllkInstance_g.m_DllIdentParam.
 772                                           m_qwVendorSpecificExt1);
 773                         // VerifyConfigurationDate
 774                         AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 775                                         m_IdentResponse.
 776                                         m_le_dwVerifyConfigurationDate,
 777                                         EplDllkInstance_g.m_DllIdentParam.
 778                                         m_dwVerifyConfigurationDate);
 779                         // VerifyConfigurationTime
 780                         AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 781                                         m_IdentResponse.
 782                                         m_le_dwVerifyConfigurationTime,
 783                                         EplDllkInstance_g.m_DllIdentParam.
 784                                         m_dwVerifyConfigurationTime);
 785                         // ApplicationSwDate
 786                         AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 787                                         m_IdentResponse.
 788                                         m_le_dwApplicationSwDate,
 789                                         EplDllkInstance_g.m_DllIdentParam.
 790                                         m_dwApplicationSwDate);
 791                         // ApplicationSwTime
 792                         AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 793                                         m_IdentResponse.
 794                                         m_le_dwApplicationSwTime,
 795                                         EplDllkInstance_g.m_DllIdentParam.
 796                                         m_dwApplicationSwTime);
 797                         // IPAddress
 798                         AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 799                                         m_IdentResponse.m_le_dwIpAddress,
 800                                         EplDllkInstance_g.m_DllIdentParam.
 801                                         m_dwIpAddress);
 802                         // SubnetMask
 803                         AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 804                                         m_IdentResponse.m_le_dwSubnetMask,
 805                                         EplDllkInstance_g.m_DllIdentParam.
 806                                         m_dwSubnetMask);
 807                         // DefaultGateway
 808                         AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.
 809                                         m_IdentResponse.m_le_dwDefaultGateway,
 810                                         EplDllkInstance_g.m_DllIdentParam.
 811                                         m_dwDefaultGateway);
 812                         // HostName
 813                         EPL_MEMCPY(&pTxFrame->m_Data.m_Asnd.m_Payload.
 814                                    m_IdentResponse.m_le_sHostname[0],
 815                                    &EplDllkInstance_g.m_DllIdentParam.
 816                                    m_sHostname[0],
 817                                    sizeof(EplDllkInstance_g.m_DllIdentParam.
 818                                           m_sHostname));
 819                         // VendorSpecificExt2
 820                         EPL_MEMCPY(&pTxFrame->m_Data.m_Asnd.m_Payload.
 821                                    m_IdentResponse.m_le_abVendorSpecificExt2[0],
 822                                    &EplDllkInstance_g.m_DllIdentParam.
 823                                    m_abVendorSpecificExt2[0],
 824                                    sizeof(EplDllkInstance_g.m_DllIdentParam.
 825                                           m_abVendorSpecificExt2));
 826
 827                         // StatusResponse
 828                         uiFrameSize = EPL_C_DLL_MINSIZE_STATUSRES;
 829                         Ret =
 830                             EplDllkCreateTxFrame(&uiHandle, &pTxFrame,
 831                                                  &uiFrameSize, kEplMsgTypeAsnd,
 832                                                  kEplDllAsndStatusResponse);
 833                         if (Ret != kEplSuccessful) {    // error occured while registering Tx frame
 834                                 goto Exit;
 835                         }
 836                         // PRes $$$ maybe move this to PDO module
 837                         if ((EplDllkInstance_g.m_DllConfigParam.m_fAsyncOnly ==
 838                              FALSE)
 839                             && (EplDllkInstance_g.m_DllConfigParam.m_uiPresActPayloadLimit >= 36)) {    // it is not configured as async-only CN,
 840                                 // so take part in isochronous phase and register PRes frame
 841                                 uiFrameSize =
 842                                     EplDllkInstance_g.m_DllConfigParam.
 843                                     m_uiPresActPayloadLimit + 24;
 844                                 Ret =
 845                                     EplDllkCreateTxFrame(&uiHandle, &pTxFrame,
 846                                                          &uiFrameSize,
 847                                                          kEplMsgTypePres,
 848                                                          kEplDllAsndNotDefined);
 849                                 if (Ret != kEplSuccessful) {    // error occured while registering Tx frame
 850                                         goto Exit;
 851                                 }
 852 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
 853                                 // initially encode TPDO -> inform PDO module
 854                                 FrameInfo.m_pFrame = pTxFrame;
 855                                 FrameInfo.m_uiFrameSize = uiFrameSize;
 856                                 Ret = EplPdokCbPdoTransmitted(&FrameInfo);
 857 #endif
 858                                 // reset cycle counter
 859                                 EplDllkInstance_g.m_uiCycleCount = 0;
 860                         } else {        // it is an async-only CN
 861                                 // fool EplDllkChangeState() to think that PRes was not expected
 862                                 EplDllkInstance_g.m_uiCycleCount = 1;
 863                         }
 864
 865                         // NMT request
 866                         uiFrameSize = EPL_C_IP_MAX_MTU;
 867                         Ret =
 868                             EplDllkCreateTxFrame(&uiHandle, &pTxFrame,
 869                                                  &uiFrameSize, kEplMsgTypeAsnd,
 870                                                  kEplDllAsndNmtRequest);
 871                         if (Ret != kEplSuccessful) {    // error occured while registering Tx frame
 872                                 goto Exit;
 873                         }
 874                         // mark Tx buffer as empty
 875                         EplDllkInstance_g.m_pTxBuffer[uiHandle].m_uiTxMsgLen =
 876                             EPL_DLLK_BUFLEN_EMPTY;
 877
 878                         // non-EPL frame
 879                         uiFrameSize = EPL_C_IP_MAX_MTU;
 880                         Ret =
 881                             EplDllkCreateTxFrame(&uiHandle, &pTxFrame,
 882                                                  &uiFrameSize,
 883                                                  kEplMsgTypeNonEpl,
 884                                                  kEplDllAsndNotDefined);
 885                         if (Ret != kEplSuccessful) {    // error occured while registering Tx frame
 886                                 goto Exit;
 887                         }
 888                         // mark Tx buffer as empty
 889                         EplDllkInstance_g.m_pTxBuffer[uiHandle].m_uiTxMsgLen =
 890                             EPL_DLLK_BUFLEN_EMPTY;
 891
 892                         // register multicast MACs in ethernet driver
 893                         AmiSetQword48ToBe(&abMulticastMac[0],
 894                                           EPL_C_DLL_MULTICAST_SOC);
 895                         Ret = EdrvDefineRxMacAddrEntry(abMulticastMac);
 896                         AmiSetQword48ToBe(&abMulticastMac[0],
 897                                           EPL_C_DLL_MULTICAST_SOA);
 898                         Ret = EdrvDefineRxMacAddrEntry(abMulticastMac);
 899                         AmiSetQword48ToBe(&abMulticastMac[0],
 900                                           EPL_C_DLL_MULTICAST_PRES);
 901                         Ret = EdrvDefineRxMacAddrEntry(abMulticastMac);
 902                         AmiSetQword48ToBe(&abMulticastMac[0],
 903                                           EPL_C_DLL_MULTICAST_ASND);
 904                         Ret = EdrvDefineRxMacAddrEntry(abMulticastMac);
 905
 906 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
 907                         if (NmtState >= kEplNmtMsNotActive) {   // local node is MN
 908                                 unsigned int uiIndex;
 909
 910                                 // SoC
 911                                 uiFrameSize = EPL_C_DLL_MINSIZE_SOC;
 912                                 Ret =
 913                                     EplDllkCreateTxFrame(&uiHandle, &pTxFrame,
 914                                                          &uiFrameSize,
 915                                                          kEplMsgTypeSoc,
 916                                                          kEplDllAsndNotDefined);
 917                                 if (Ret != kEplSuccessful) {    // error occured while registering Tx frame
 918                                         goto Exit;
 919                                 }
 920                                 // SoA
 921                                 uiFrameSize = EPL_C_DLL_MINSIZE_SOA;
 922                                 Ret =
 923                                     EplDllkCreateTxFrame(&uiHandle, &pTxFrame,
 924                                                          &uiFrameSize,
 925                                                          kEplMsgTypeSoa,
 926                                                          kEplDllAsndNotDefined);
 927                                 if (Ret != kEplSuccessful) {    // error occured while registering Tx frame
 928                                         goto Exit;
 929                                 }
 930
 931                                 for (uiIndex = 0;
 932                                      uiIndex <
 933                                      tabentries(EplDllkInstance_g.m_aNodeInfo);
 934                                      uiIndex++) {
 935 //                    EplDllkInstance_g.m_aNodeInfo[uiIndex].m_uiNodeId = uiIndex + 1;
 936                                         EplDllkInstance_g.m_aNodeInfo[uiIndex].
 937                                             m_wPresPayloadLimit =
 938                                             (u16) EplDllkInstance_g.
 939                                             m_DllConfigParam.
 940                                             m_uiIsochrRxMaxPayload;
 941                                 }
 942
 943                                 // calculate cycle length
 944                                 EplDllkInstance_g.m_ullFrameTimeout = 1000LL
 945                                     *
 946                                     ((unsigned long long)EplDllkInstance_g.
 947                                      m_DllConfigParam.m_dwCycleLen);
 948                         }
 949 #endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
 950
 951                         Ret = EplDllkCalAsyncClearBuffer();
 952
 953                         break;
 954                 }
 955
 956         case kEplEventTypeDllkDestroy:
 957                 {
 958                         // destroy all data structures
 959
 960                         NmtState = *((tEplNmtState *) pEvent_p->m_pArg);
 961
 962                         // delete Tx frames
 963                         Ret = EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_IDENTRES);
 964                         if (Ret != kEplSuccessful) {    // error occured while deregistering Tx frame
 965                                 goto Exit;
 966                         }
 967
 968                         Ret = EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_STATUSRES);
 969                         if (Ret != kEplSuccessful) {    // error occured while deregistering Tx frame
 970                                 goto Exit;
 971                         }
 972
 973                         Ret = EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_PRES);
 974                         if (Ret != kEplSuccessful) {    // error occured while deregistering Tx frame
 975                                 goto Exit;
 976                         }
 977
 978                         Ret = EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_NMTREQ);
 979                         if (Ret != kEplSuccessful) {    // error occured while deregistering Tx frame
 980                                 goto Exit;
 981                         }
 982
 983                         Ret = EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_NONEPL);
 984                         if (Ret != kEplSuccessful) {    // error occured while deregistering Tx frame
 985                                 goto Exit;
 986                         }
 987 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
 988                         if (NmtState >= kEplNmtMsNotActive) {   // local node was MN
 989                                 unsigned int uiIndex;
 990
 991                                 Ret =
 992                                     EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_SOC);
 993                                 if (Ret != kEplSuccessful) {    // error occured while deregistering Tx frame
 994                                         goto Exit;
 995                                 }
 996
 997                                 Ret =
 998                                     EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_SOA);
 999                                 if (Ret != kEplSuccessful) {    // error occured while deregistering Tx frame
1000                                         goto Exit;
1001                                 }
1002
1003                                 for (uiIndex = 0;
1004                                      uiIndex <
1005                                      tabentries(EplDllkInstance_g.m_aNodeInfo);
1006                                      uiIndex++) {
1007                                         if (EplDllkInstance_g.
1008                                             m_aNodeInfo[uiIndex].
1009                                             m_pPreqTxBuffer != NULL) {
1010                                                 uiHandle =
1011                                                     EplDllkInstance_g.
1012                                                     m_aNodeInfo[uiIndex].
1013                                                     m_pPreqTxBuffer -
1014                                                     EplDllkInstance_g.
1015                                                     m_pTxBuffer;
1016                                                 EplDllkInstance_g.
1017                                                     m_aNodeInfo[uiIndex].
1018                                                     m_pPreqTxBuffer = NULL;
1019                                                 Ret =
1020                                                     EplDllkDeleteTxFrame
1021                                                     (uiHandle);
1022                                                 if (Ret != kEplSuccessful) {    // error occured while deregistering Tx frame
1023                                                         goto Exit;
1024                                                 }
1025
1026                                         }
1027                                         EplDllkInstance_g.m_aNodeInfo[uiIndex].
1028                                             m_wPresPayloadLimit = 0xFFFF;
1029                                 }
1030                         }
1031 #endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
1032
1033                         // deregister multicast MACs in ethernet driver
1034                         AmiSetQword48ToBe(&abMulticastMac[0],
1035                                           EPL_C_DLL_MULTICAST_SOC);
1036                         Ret = EdrvUndefineRxMacAddrEntry(abMulticastMac);
1037                         AmiSetQword48ToBe(&abMulticastMac[0],
1038                                           EPL_C_DLL_MULTICAST_SOA);
1039                         Ret = EdrvUndefineRxMacAddrEntry(abMulticastMac);
1040                         AmiSetQword48ToBe(&abMulticastMac[0],
1041                                           EPL_C_DLL_MULTICAST_PRES);
1042                         Ret = EdrvUndefineRxMacAddrEntry(abMulticastMac);
1043                         AmiSetQword48ToBe(&abMulticastMac[0],
1044                                           EPL_C_DLL_MULTICAST_ASND);
1045                         Ret = EdrvUndefineRxMacAddrEntry(abMulticastMac);
1046
1047                         // delete timer
1048 #if EPL_TIMER_USE_HIGHRES != FALSE
1049                         Ret =
1050                             EplTimerHighReskDeleteTimer(&EplDllkInstance_g.
1051                                                         m_TimerHdlCycle);
1052 #endif
1053
1054                         break;
1055                 }
1056
1057         case kEplEventTypeDllkFillTx:
1058                 {
1059                         // fill TxBuffer of specified priority with new frame if empty
1060
1061                         pTxFrame = NULL;
1062                         AsyncReqPriority =
1063                             *((tEplDllAsyncReqPriority *) pEvent_p->m_pArg);
1064                         switch (AsyncReqPriority) {
1065                         case kEplDllAsyncReqPrioNmt:    // NMT request priority
1066                                 {
1067                                         pTxBuffer =
1068                                             &EplDllkInstance_g.
1069                                             m_pTxBuffer
1070                                             [EPL_DLLK_TXFRAME_NMTREQ];
1071                                         if (pTxBuffer->m_pbBuffer != NULL) {    // NmtRequest does exist
1072                                                 // check if frame is empty and not being filled
1073                                                 if (pTxBuffer->m_uiTxMsgLen ==
1074                                                     EPL_DLLK_BUFLEN_EMPTY) {
1075                                                         // mark Tx buffer as filling is in process
1076                                                         pTxBuffer->
1077                                                             m_uiTxMsgLen =
1078                                                             EPL_DLLK_BUFLEN_FILLING;
1079                                                         // set max buffer size as input parameter
1080                                                         uiFrameSize =
1081                                                             pTxBuffer->
1082                                                             m_uiMaxBufferLen;
1083                                                         // copy frame from shared loop buffer to Tx buffer
1084                                                         Ret =
1085                                                             EplDllkCalAsyncGetTxFrame
1086                                                             (pTxBuffer->
1087                                                              m_pbBuffer,
1088                                                              &uiFrameSize,
1089                                                              AsyncReqPriority);
1090                                                         if (Ret ==
1091                                                             kEplSuccessful) {
1092                                                                 pTxFrame =
1093                                                                     (tEplFrame
1094                                                                      *)
1095                                                                     pTxBuffer->
1096                                                                     m_pbBuffer;
1097                                                                 Ret =
1098                                                                     EplDllkCheckFrame
1099                                                                     (pTxFrame,
1100                                                                      uiFrameSize);
1101
1102                                                                 // set buffer valid
1103                                                                 pTxBuffer->
1104                                                                     m_uiTxMsgLen
1105                                                                     =
1106                                                                     uiFrameSize;
1107                                                         } else if (Ret == kEplDllAsyncTxBufferEmpty) {  // empty Tx buffer is not a real problem
1108                                                                 // so just ignore it
1109                                                                 Ret =
1110                                                                     kEplSuccessful;
1111                                                                 // mark Tx buffer as empty
1112                                                                 pTxBuffer->
1113                                                                     m_uiTxMsgLen
1114                                                                     =
1115                                                                     EPL_DLLK_BUFLEN_EMPTY;
1116                                                         }
1117                                                 }
1118                                         }
1119                                         break;
1120                                 }
1121
1122                         default:        // generic priority
1123                                 {
1124                                         pTxBuffer =
1125                                             &EplDllkInstance_g.
1126                                             m_pTxBuffer
1127                                             [EPL_DLLK_TXFRAME_NONEPL];
1128                                         if (pTxBuffer->m_pbBuffer != NULL) {    // non-EPL frame does exist
1129                                                 // check if frame is empty and not being filled
1130                                                 if (pTxBuffer->m_uiTxMsgLen ==
1131                                                     EPL_DLLK_BUFLEN_EMPTY) {
1132                                                         // mark Tx buffer as filling is in process
1133                                                         pTxBuffer->
1134                                                             m_uiTxMsgLen =
1135                                                             EPL_DLLK_BUFLEN_FILLING;
1136                                                         // set max buffer size as input parameter
1137                                                         uiFrameSize =
1138                                                             pTxBuffer->
1139                                                             m_uiMaxBufferLen;
1140                                                         // copy frame from shared loop buffer to Tx buffer
1141                                                         Ret =
1142                                                             EplDllkCalAsyncGetTxFrame
1143                                                             (pTxBuffer->
1144                                                              m_pbBuffer,
1145                                                              &uiFrameSize,
1146                                                              AsyncReqPriority);
1147                                                         if (Ret ==
1148                                                             kEplSuccessful) {
1149                                                                 pTxFrame =
1150                                                                     (tEplFrame
1151                                                                      *)
1152                                                                     pTxBuffer->
1153                                                                     m_pbBuffer;
1154                                                                 Ret =
1155                                                                     EplDllkCheckFrame
1156                                                                     (pTxFrame,
1157                                                                      uiFrameSize);
1158
1159                                                                 // set buffer valid
1160                                                                 pTxBuffer->
1161                                                                     m_uiTxMsgLen
1162                                                                     =
1163                                                                     uiFrameSize;
1164                                                         } else if (Ret == kEplDllAsyncTxBufferEmpty) {  // empty Tx buffer is not a real problem
1165                                                                 // so just ignore it
1166                                                                 Ret =
1167                                                                     kEplSuccessful;
1168                                                                 // mark Tx buffer as empty
1169                                                                 pTxBuffer->
1170                                                                     m_uiTxMsgLen
1171                                                                     =
1172                                                                     EPL_DLLK_BUFLEN_EMPTY;
1173                                                         }
1174                                                 }
1175                                         }
1176                                         break;
1177                                 }
1178                         }
1179
1180                         NmtState = EplNmtkGetNmtState();
1181
1182                         if ((NmtState == kEplNmtCsBasicEthernet) || (NmtState == kEplNmtMsBasicEthernet)) {     // send frame immediately
1183                                 if (pTxFrame != NULL) { // frame is present
1184                                         // padding is done by Edrv or ethernet controller
1185                                         Ret = EdrvSendTxMsg(pTxBuffer);
1186                                 } else {        // no frame moved to TxBuffer
1187                                         // check if TxBuffers contain unsent frames
1188                                         if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen > EPL_DLLK_BUFLEN_EMPTY) {      // NMT request Tx buffer contains a frame
1189                                                 Ret =
1190                                                     EdrvSendTxMsg
1191                                                     (&EplDllkInstance_g.
1192                                                      m_pTxBuffer
1193                                                      [EPL_DLLK_TXFRAME_NMTREQ]);
1194                                         } else if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NONEPL].m_uiTxMsgLen > EPL_DLLK_BUFLEN_EMPTY) {       // non-EPL Tx buffer contains a frame
1195                                                 Ret =
1196                                                     EdrvSendTxMsg
1197                                                     (&EplDllkInstance_g.
1198                                                      m_pTxBuffer
1199                                                      [EPL_DLLK_TXFRAME_NONEPL]);
1200                                         }
1201                                         if (Ret == kEplInvalidOperation) {      // ignore error if caused by already active transmission
1202                                                 Ret = kEplSuccessful;
1203                                         }
1204                                 }
1205                                 // reset PRes flag 2
1206                                 EplDllkInstance_g.m_bFlag2 = 0;
1207                         } else {
1208                                 // update Flag 2 (PR, RS)
1209                                 Ret =
1210                                     EplDllkCalAsyncGetTxCount(&AsyncReqPriority,
1211                                                               &uiFrameCount);
1212                                 if (AsyncReqPriority == kEplDllAsyncReqPrioNmt) {       // non-empty FIFO with hightest priority is for NMT requests
1213                                         if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen > EPL_DLLK_BUFLEN_EMPTY) {      // NMT request Tx buffer contains a frame
1214                                                 // add one more frame
1215                                                 uiFrameCount++;
1216                                         }
1217                                 } else {        // non-empty FIFO with highest priority is for generic frames
1218                                         if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen > EPL_DLLK_BUFLEN_EMPTY) {      // NMT request Tx buffer contains a frame
1219                                                 // use NMT request FIFO, because of higher priority
1220                                                 uiFrameCount = 1;
1221                                                 AsyncReqPriority =
1222                                                     kEplDllAsyncReqPrioNmt;
1223                                         } else if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NONEPL].m_uiTxMsgLen > EPL_DLLK_BUFLEN_EMPTY) {       // non-EPL Tx buffer contains a frame
1224                                                 // use NMT request FIFO, because of higher priority
1225                                                 // add one more frame
1226                                                 uiFrameCount++;
1227                                         }
1228                                 }
1229
1230                                 if (uiFrameCount > 7) { // limit frame request to send counter to 7
1231                                         uiFrameCount = 7;
1232                                 }
1233                                 if (uiFrameCount > 0) {
1234                                         EplDllkInstance_g.m_bFlag2 =
1235                                             (u8) (((AsyncReqPriority <<
1236                                                       EPL_FRAME_FLAG2_PR_SHIFT)
1237                                                      & EPL_FRAME_FLAG2_PR)
1238                                                     | (uiFrameCount &
1239                                                        EPL_FRAME_FLAG2_RS));
1240                                 } else {
1241                                         EplDllkInstance_g.m_bFlag2 = 0;
1242                                 }
1243                         }
1244
1245                         break;
1246                 }
1247
1248 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
1249         case kEplEventTypeDllkStartReducedCycle:
1250                 {
1251                         // start the reduced cycle by programming the cycle timer
1252                         // it is issued by NMT MN module, when PreOp1 is entered
1253
1254                         // clear the asynchronous queues
1255                         Ret = EplDllkCalAsyncClearQueues();
1256
1257                         // reset cycle counter (everytime a SoA is triggerd in PreOp1 the counter is incremented
1258                         // and when it reaches EPL_C_DLL_PREOP1_START_CYCLES the SoA may contain invitations)
1259                         EplDllkInstance_g.m_uiCycleCount = 0;
1260
1261                         // remove any CN from isochronous phase
1262                         while (EplDllkInstance_g.m_pFirstNodeInfo != NULL) {
1263                                 EplDllkDeleteNode(EplDllkInstance_g.
1264                                                   m_pFirstNodeInfo->m_uiNodeId);
1265                         }
1266
1267                         // change state to NonCyclic,
1268                         // hence EplDllkChangeState() will not ignore the next call
1269                         EplDllkInstance_g.m_DllState = kEplDllMsNonCyclic;
1270
1271 #if EPL_TIMER_USE_HIGHRES != FALSE
1272                         if (EplDllkInstance_g.m_DllConfigParam.
1273                             m_dwAsyncSlotTimeout != 0) {
1274                                 Ret =
1275                                     EplTimerHighReskModifyTimerNs
1276                                     (&EplDllkInstance_g.m_TimerHdlCycle,
1277                                      EplDllkInstance_g.m_DllConfigParam.
1278                                      m_dwAsyncSlotTimeout,
1279                                      EplDllkCbMnTimerCycle, 0L, FALSE);
1280                         }
1281 #endif
1282
1283                         break;
1284                 }
1285 #endif
1286
1287 #if EPL_DLL_PRES_READY_AFTER_SOA != FALSE
1288         case kEplEventTypeDllkPresReady:
1289                 {
1290                         // post PRes to transmit FIFO
1291
1292                         NmtState = EplNmtkGetNmtState();
1293
1294                         if (NmtState != kEplNmtCsBasicEthernet) {
1295                                 // Does PRes exist?
1296                                 if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_PRES].m_pbBuffer != NULL) {  // PRes does exist
1297                                         pTxFrame =
1298                                             (tEplFrame *) EplDllkInstance_g.
1299                                             m_pTxBuffer[EPL_DLLK_TXFRAME_PRES].
1300                                             m_pbBuffer;
1301                                         // update frame (NMT state, RD, RS, PR, MS, EN flags)
1302                                         if (NmtState < kEplNmtCsPreOperational2) {      // NMT state is not PreOp2, ReadyToOp or Op
1303                                                 // fake NMT state PreOp2, because PRes will be sent only in PreOp2 or greater
1304                                                 NmtState =
1305                                                     kEplNmtCsPreOperational2;
1306                                         }
1307                                         AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.
1308                                                        m_le_bNmtStatus,
1309                                                        (u8) NmtState);
1310                                         AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.
1311                                                        m_le_bFlag2,
1312                                                        EplDllkInstance_g.
1313                                                        m_bFlag2);
1314                                         if (NmtState != kEplNmtCsOperational) { // mark PDO as invalid in NMT state Op
1315                                                 // $$$ reset only RD flag; set other flags appropriately
1316                                                 AmiSetByteToLe(&pTxFrame->
1317                                                                m_Data.m_Pres.
1318                                                                m_le_bFlag1, 0);
1319                                         }
1320                                         // $$$ make function that updates Pres, StatusRes
1321                                         // mark PRes frame as ready for transmission
1322                                         Ret =
1323                                             EdrvTxMsgReady(&EplDllkInstance_g.
1324                                                            m_pTxBuffer
1325                                                            [EPL_DLLK_TXFRAME_PRES]);
1326                                 }
1327                         }
1328
1329                         break;
1330                 }
1331 #endif
1332         default:
1333                 {
1334                         ASSERTMSG(FALSE,
1335                                   "EplDllkProcess(): unhandled event type!\n");
1336                 }
1337         }
1338
1339       Exit:
1340         return Ret;
1341 }
1342
1343 //---------------------------------------------------------------------------
1344 //
1345 // Function:    EplDllkConfig
1346 //
1347 // Description: configure parameters of DLL
1348 //
1349 // Parameters:  pDllConfigParam_p       = configuration parameters
1350 //
1351 // Returns:     tEplKernel              = error code
1352 //
1353 //
1354 // State:
1355 //
1356 //---------------------------------------------------------------------------
1357
1358 tEplKernel EplDllkConfig(tEplDllConfigParam * pDllConfigParam_p)
1359 {
1360         tEplKernel Ret = kEplSuccessful;
1361
1362 // d.k. check of NMT state disabled, because CycleLen is programmed at run time by MN without reset of CN
1363 /*tEplNmtState    NmtState;
1364
1365     NmtState = EplNmtkGetNmtState();
1366
1367     if (NmtState > kEplNmtGsResetConfiguration)
1368     {   // only allowed in state DLL_GS_INIT
1369         Ret = kEplInvalidOperation;
1370         goto Exit;
1371     }
1372 */
1373         EPL_MEMCPY(&EplDllkInstance_g.m_DllConfigParam, pDllConfigParam_p,
1374                    (pDllConfigParam_p->m_uiSizeOfStruct <
1375                     sizeof(tEplDllConfigParam) ? pDllConfigParam_p->
1376                     m_uiSizeOfStruct : sizeof(tEplDllConfigParam)));
1377
1378         if ((EplDllkInstance_g.m_DllConfigParam.m_dwCycleLen != 0)
1379             && (EplDllkInstance_g.m_DllConfigParam.m_dwLossOfFrameTolerance != 0)) {    // monitor EPL cycle, calculate frame timeout
1380                 EplDllkInstance_g.m_ullFrameTimeout = (1000LL
1381                                                        *
1382                                                        ((unsigned long long)
1383                                                         EplDllkInstance_g.
1384                                                         m_DllConfigParam.
1385                                                         m_dwCycleLen))
1386                     +
1387                     ((unsigned long long)EplDllkInstance_g.m_DllConfigParam.
1388                      m_dwLossOfFrameTolerance);
1389         } else {
1390                 EplDllkInstance_g.m_ullFrameTimeout = 0LL;
1391         }
1392
1393         if (EplDllkInstance_g.m_DllConfigParam.m_fAsyncOnly != FALSE) { // it is configured as async-only CN
1394                 // disable multiplexed cycle, that m_uiCycleCount will not be incremented spuriously on SoC
1395                 EplDllkInstance_g.m_DllConfigParam.m_uiMultiplCycleCnt = 0;
1396         }
1397 //Exit:
1398         return Ret;
1399 }
1400
1401 //---------------------------------------------------------------------------
1402 //
1403 // Function:    EplDllkSetIdentity
1404 //
1405 // Description: configure identity of local node for IdentResponse
1406 //
1407 // Parameters:  pDllIdentParam_p        = identity
1408 //
1409 // Returns:     tEplKernel              = error code
1410 //
1411 //
1412 // State:
1413 //
1414 //---------------------------------------------------------------------------
1415
1416 tEplKernel EplDllkSetIdentity(tEplDllIdentParam * pDllIdentParam_p)
1417 {
1418         tEplKernel Ret = kEplSuccessful;
1419
1420         EPL_MEMCPY(&EplDllkInstance_g.m_DllIdentParam, pDllIdentParam_p,
1421                    (pDllIdentParam_p->m_uiSizeOfStruct <
1422                     sizeof(tEplDllIdentParam) ? pDllIdentParam_p->
1423                     m_uiSizeOfStruct : sizeof(tEplDllIdentParam)));
1424
1425         // $$$ if IdentResponse frame exists update it
1426
1427         return Ret;
1428 }
1429
1430 //---------------------------------------------------------------------------
1431 //
1432 // Function:    EplDllkRegAsyncHandler
1433 //
1434 // Description: registers handler for non-EPL frames
1435 //
1436 // Parameters:  pfnDllkCbAsync_p        = pointer to callback function
1437 //
1438 // Returns:     tEplKernel              = error code
1439 //
1440 //
1441 // State:
1442 //
1443 //---------------------------------------------------------------------------
1444
1445 tEplKernel EplDllkRegAsyncHandler(tEplDllkCbAsync pfnDllkCbAsync_p)
1446 {
1447         tEplKernel Ret = kEplSuccessful;
1448
1449         if (EplDllkInstance_g.m_pfnCbAsync == NULL) {   // no handler registered yet
1450                 EplDllkInstance_g.m_pfnCbAsync = pfnDllkCbAsync_p;
1451         } else {                // handler already registered
1452                 Ret = kEplDllCbAsyncRegistered;
1453         }
1454
1455         return Ret;
1456 }
1457
1458 //---------------------------------------------------------------------------
1459 //
1460 // Function:    EplDllkDeregAsyncHandler
1461 //
1462 // Description: deregisters handler for non-EPL frames
1463 //
1464 // Parameters:  pfnDllkCbAsync_p        = pointer to callback function
1465 //
1466 // Returns:     tEplKernel              = error code
1467 //
1468 //
1469 // State:
1470 //
1471 //---------------------------------------------------------------------------
1472
1473 tEplKernel EplDllkDeregAsyncHandler(tEplDllkCbAsync pfnDllkCbAsync_p)
1474 {
1475         tEplKernel Ret = kEplSuccessful;
1476
1477         if (EplDllkInstance_g.m_pfnCbAsync == pfnDllkCbAsync_p) {       // same handler is registered
1478                 // deregister it
1479                 EplDllkInstance_g.m_pfnCbAsync = NULL;
1480         } else {                // wrong handler or no handler registered
1481                 Ret = kEplDllCbAsyncRegistered;
1482         }
1483
1484         return Ret;
1485 }
1486
1487 //---------------------------------------------------------------------------
1488 //
1489 // Function:    EplDllkSetAsndServiceIdFilter()
1490 //
1491 // Description: sets the specified node ID filter for the specified
1492 //              AsndServiceId. It registers C_DLL_MULTICAST_ASND in ethernet
1493 //              driver if any AsndServiceId is open.
1494 //
1495 // Parameters:  ServiceId_p             = ASnd Service ID
1496 //              Filter_p                = node ID filter
1497 //
1498 // Returns:     tEplKernel              = error code
1499 //
1500 //
1501 // State:
1502 //
1503 //---------------------------------------------------------------------------
1504
1505 tEplKernel EplDllkSetAsndServiceIdFilter(tEplDllAsndServiceId ServiceId_p,
1506                                          tEplDllAsndFilter Filter_p)
1507 {
1508         tEplKernel Ret = kEplSuccessful;
1509
1510         if (ServiceId_p < tabentries(EplDllkInstance_g.m_aAsndFilter)) {
1511                 EplDllkInstance_g.m_aAsndFilter[ServiceId_p] = Filter_p;
1512         }
1513
1514         return Ret;
1515 }
1516
1517 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
1518
1519 //---------------------------------------------------------------------------
1520 //
1521 // Function:    EplDllkSetFlag1OfNode()
1522 //
1523 // Description: sets Flag1 (for PReq and SoA) of the specified node ID.
1524 //
1525 // Parameters:  uiNodeId_p              = node ID
1526 //              bSoaFlag1_p             = flag1
1527 //
1528 // Returns:     tEplKernel              = error code
1529 //
1530 //
1531 // State:
1532 //
1533 //---------------------------------------------------------------------------
1534
1535 tEplKernel EplDllkSetFlag1OfNode(unsigned int uiNodeId_p, u8 bSoaFlag1_p)
1536 {
1537         tEplKernel Ret = kEplSuccessful;
1538         tEplDllkNodeInfo *pNodeInfo;
1539
1540         pNodeInfo = EplDllkGetNodeInfo(uiNodeId_p);
1541         if (pNodeInfo == NULL) {        // no node info structure available
1542                 Ret = kEplDllNoNodeInfo;
1543                 goto Exit;
1544         }
1545         // store flag1 in internal node info structure
1546         pNodeInfo->m_bSoaFlag1 = bSoaFlag1_p;
1547
1548       Exit:
1549         return Ret;
1550 }
1551
1552 //---------------------------------------------------------------------------
1553 //
1554 // Function:    EplDllkGetFirstNodeInfo()
1555 //
1556 // Description: returns first info structure of first node in isochronous phase.
1557 //              It is only useful for ErrorHandlerk module.
1558 //
1559 // Parameters:  ppNodeInfo_p            = pointer to pointer of internal node info structure
1560 //
1561 // Returns:     tEplKernel              = error code
1562 //
1563 //
1564 // State:
1565 //
1566 //---------------------------------------------------------------------------
1567
1568 tEplKernel EplDllkGetFirstNodeInfo(tEplDllkNodeInfo ** ppNodeInfo_p)
1569 {
1570         tEplKernel Ret = kEplSuccessful;
1571
1572         *ppNodeInfo_p = EplDllkInstance_g.m_pFirstNodeInfo;
1573
1574         return Ret;
1575 }
1576
1577 //---------------------------------------------------------------------------
1578 //
1579 // Function:    EplDllkAddNode()
1580 //
1581 // Description: adds the specified node to the isochronous phase.
1582 //
1583 // Parameters:  pNodeInfo_p             = pointer of node info structure
1584 //
1585 // Returns:     tEplKernel              = error code
1586 //
1587 //
1588 // State:
1589 //
1590 //---------------------------------------------------------------------------
1591
1592 tEplKernel EplDllkAddNode(tEplDllNodeInfo * pNodeInfo_p)
1593 {
1594         tEplKernel Ret = kEplSuccessful;
1595         tEplDllkNodeInfo *pIntNodeInfo;
1596         tEplDllkNodeInfo **ppIntNodeInfo;
1597         unsigned int uiHandle;
1598         tEplFrame *pFrame;
1599         unsigned int uiFrameSize;
1600
1601         pIntNodeInfo = EplDllkGetNodeInfo(pNodeInfo_p->m_uiNodeId);
1602         if (pIntNodeInfo == NULL) {     // no node info structure available
1603                 Ret = kEplDllNoNodeInfo;
1604                 goto Exit;
1605         }
1606
1607         EPL_DLLK_DBG_POST_TRACE_VALUE(kEplEventTypeDllkAddNode,
1608                                       pNodeInfo_p->m_uiNodeId, 0);
1609
1610         // copy node configuration
1611         pIntNodeInfo->m_dwPresTimeout = pNodeInfo_p->m_dwPresTimeout;
1612         pIntNodeInfo->m_wPresPayloadLimit = pNodeInfo_p->m_wPresPayloadLimit;
1613
1614         // $$$ d.k.: actually add node only if MN. On CN it is sufficient to update the node configuration
1615         if (pNodeInfo_p->m_uiNodeId == EplDllkInstance_g.m_DllConfigParam.m_uiNodeId) { // we shall send PRes ourself
1616                 // insert our node at the end of the list
1617                 ppIntNodeInfo = &EplDllkInstance_g.m_pFirstNodeInfo;
1618                 while ((*ppIntNodeInfo != NULL)
1619                        && ((*ppIntNodeInfo)->m_pNextNodeInfo != NULL)) {
1620                         ppIntNodeInfo = &(*ppIntNodeInfo)->m_pNextNodeInfo;
1621                 }
1622                 if (*ppIntNodeInfo != NULL) {
1623                         if ((*ppIntNodeInfo)->m_uiNodeId == pNodeInfo_p->m_uiNodeId) {  // node was already added to list
1624                                 // $$$ d.k. maybe this should be an error
1625                                 goto Exit;
1626                         } else {        // add our node at the end of the list
1627                                 ppIntNodeInfo =
1628                                     &(*ppIntNodeInfo)->m_pNextNodeInfo;
1629                         }
1630                 }
1631                 // set "PReq"-TxBuffer to PRes-TxBuffer
1632                 pIntNodeInfo->m_pPreqTxBuffer =
1633                     &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_PRES];
1634         } else {                // normal CN shall be added to isochronous phase
1635                 // insert node into list in ascending order
1636                 ppIntNodeInfo = &EplDllkInstance_g.m_pFirstNodeInfo;
1637                 while ((*ppIntNodeInfo != NULL)
1638                        && ((*ppIntNodeInfo)->m_uiNodeId <
1639                            pNodeInfo_p->m_uiNodeId)
1640                        && ((*ppIntNodeInfo)->m_uiNodeId !=
1641                            EplDllkInstance_g.m_DllConfigParam.m_uiNodeId)) {
1642                         ppIntNodeInfo = &(*ppIntNodeInfo)->m_pNextNodeInfo;
1643                 }
1644                 if ((*ppIntNodeInfo != NULL) && ((*ppIntNodeInfo)->m_uiNodeId == pNodeInfo_p->m_uiNodeId)) {    // node was already added to list
1645                         // $$$ d.k. maybe this should be an error
1646                         goto Exit;
1647                 }
1648         }
1649
1650         // initialize elements of internal node info structure
1651         pIntNodeInfo->m_bSoaFlag1 = 0;
1652         pIntNodeInfo->m_fSoftDelete = FALSE;
1653         pIntNodeInfo->m_NmtState = kEplNmtCsNotActive;
1654         if (pIntNodeInfo->m_pPreqTxBuffer == NULL) {    // create TxBuffer entry
1655                 uiFrameSize = pNodeInfo_p->m_wPreqPayloadLimit + 24;
1656                 Ret =
1657                     EplDllkCreateTxFrame(&uiHandle, &pFrame, &uiFrameSize,
1658                                          kEplMsgTypePreq,
1659                                          kEplDllAsndNotDefined);
1660                 if (Ret != kEplSuccessful) {
1661                         goto Exit;
1662                 }
1663                 pIntNodeInfo->m_pPreqTxBuffer =
1664                     &EplDllkInstance_g.m_pTxBuffer[uiHandle];
1665                 AmiSetByteToLe(&pFrame->m_le_bDstNodeId,
1666                                (u8) pNodeInfo_p->m_uiNodeId);
1667
1668                 // set up destination MAC address
1669                 EPL_MEMCPY(pFrame->m_be_abDstMac, pIntNodeInfo->m_be_abMacAddr,
1670                            6);
1671
1672 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
1673                 {
1674                         tEplFrameInfo FrameInfo;
1675
1676                         // initially encode TPDO -> inform PDO module
1677                         FrameInfo.m_pFrame = pFrame;
1678                         FrameInfo.m_uiFrameSize = uiFrameSize;
1679                         Ret = EplPdokCbPdoTransmitted(&FrameInfo);
1680                 }
1681 #endif
1682         }
1683         pIntNodeInfo->m_ulDllErrorEvents = 0L;
1684         // add node to list
1685         pIntNodeInfo->m_pNextNodeInfo = *ppIntNodeInfo;
1686         *ppIntNodeInfo = pIntNodeInfo;
1687
1688       Exit:
1689         return Ret;
1690 }
1691
1692 //---------------------------------------------------------------------------
1693 //
1694 // Function:    EplDllkDeleteNode()
1695 //
1696 // Description: removes the specified node from the isochronous phase.
1697 //
1698 // Parameters:  uiNodeId_p              = node ID
1699 //
1700 // Returns:     tEplKernel              = error code
1701 //
1702 //
1703 // State:
1704 //
1705 //---------------------------------------------------------------------------
1706
1707 tEplKernel EplDllkDeleteNode(unsigned int uiNodeId_p)
1708 {
1709         tEplKernel Ret = kEplSuccessful;
1710         tEplDllkNodeInfo *pIntNodeInfo;
1711         tEplDllkNodeInfo **ppIntNodeInfo;
1712         unsigned int uiHandle;
1713
1714         pIntNodeInfo = EplDllkGetNodeInfo(uiNodeId_p);
1715         if (pIntNodeInfo == NULL) {     // no node info structure available
1716                 Ret = kEplDllNoNodeInfo;
1717                 goto Exit;
1718         }
1719
1720         EPL_DLLK_DBG_POST_TRACE_VALUE(kEplEventTypeDllkDelNode, uiNodeId_p, 0);
1721
1722         // search node in whole list
1723         ppIntNodeInfo = &EplDllkInstance_g.m_pFirstNodeInfo;
1724         while ((*ppIntNodeInfo != NULL)
1725                && ((*ppIntNodeInfo)->m_uiNodeId != uiNodeId_p)) {
1726                 ppIntNodeInfo = &(*ppIntNodeInfo)->m_pNextNodeInfo;
1727         }
1728         if ((*ppIntNodeInfo == NULL) || ((*ppIntNodeInfo)->m_uiNodeId != uiNodeId_p)) { // node was not found in list
1729                 // $$$ d.k. maybe this should be an error
1730                 goto Exit;
1731         }
1732         // remove node from list
1733         *ppIntNodeInfo = pIntNodeInfo->m_pNextNodeInfo;
1734
1735         if ((pIntNodeInfo->m_pPreqTxBuffer != NULL)
1736             && (pIntNodeInfo->m_pPreqTxBuffer != &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_PRES])) {      // delete TxBuffer entry
1737                 uiHandle =
1738                     pIntNodeInfo->m_pPreqTxBuffer -
1739                     EplDllkInstance_g.m_pTxBuffer;
1740                 pIntNodeInfo->m_pPreqTxBuffer = NULL;
1741                 Ret = EplDllkDeleteTxFrame(uiHandle);
1742 /*        if (Ret != kEplSuccessful)
1743         {
1744             goto Exit;
1745         }*/
1746         }
1747
1748       Exit:
1749         return Ret;
1750 }
1751
1752 //---------------------------------------------------------------------------
1753 //
1754 // Function:    EplDllkSoftDeleteNode()
1755 //
1756 // Description: removes the specified node not immediately from the isochronous phase.
1757 //              Instead the will be removed after error (late/loss PRes) without
1758 //              charging the error.
1759 //
1760 // Parameters:  uiNodeId_p              = node ID
1761 //
1762 // Returns:     tEplKernel              = error code
1763 //
1764 //
1765 // State:
1766 //
1767 //---------------------------------------------------------------------------
1768
1769 tEplKernel EplDllkSoftDeleteNode(unsigned int uiNodeId_p)
1770 {
1771         tEplKernel Ret = kEplSuccessful;
1772         tEplDllkNodeInfo *pIntNodeInfo;
1773
1774         pIntNodeInfo = EplDllkGetNodeInfo(uiNodeId_p);
1775         if (pIntNodeInfo == NULL) {     // no node info structure available
1776                 Ret = kEplDllNoNodeInfo;
1777                 goto Exit;
1778         }
1779
1780         EPL_DLLK_DBG_POST_TRACE_VALUE(kEplEventTypeDllkSoftDelNode,
1781                                       uiNodeId_p, 0);
1782
1783         pIntNodeInfo->m_fSoftDelete = TRUE;
1784
1785       Exit:
1786         return Ret;
1787 }
1788
1789 #endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
1790
1791 //=========================================================================//
1792 //                                                                         //
1793 //          P R I V A T E   F U N C T I O N S                              //
1794 //                                                                         //
1795 //=========================================================================//
1796
1797 //---------------------------------------------------------------------------
1798 //
1799 // Function:    EplDllkChangeState
1800 //
1801 // Description: change DLL state on event and diagnose some communication errors
1802 //
1803 // Parameters:  NmtEvent_p              = DLL event (wrapped in NMT event)
1804 //
1805 // Returns:     tEplKernel              = error code
1806 //
1807 //
1808 // State:
1809 //
1810 //---------------------------------------------------------------------------
1811
1812 static tEplKernel EplDllkChangeState(tEplNmtEvent NmtEvent_p,
1813                                      tEplNmtState NmtState_p)
1814 {
1815         tEplKernel Ret = kEplSuccessful;
1816         tEplEvent Event;
1817         tEplErrorHandlerkEvent DllEvent;
1818
1819         DllEvent.m_ulDllErrorEvents = 0;
1820         DllEvent.m_uiNodeId = 0;
1821         DllEvent.m_NmtState = NmtState_p;
1822
1823         switch (NmtState_p) {
1824         case kEplNmtGsOff:
1825         case kEplNmtGsInitialising:
1826         case kEplNmtGsResetApplication:
1827         case kEplNmtGsResetCommunication:
1828         case kEplNmtGsResetConfiguration:
1829         case kEplNmtCsBasicEthernet:
1830                 // enter DLL_GS_INIT
1831                 EplDllkInstance_g.m_DllState = kEplDllGsInit;
1832                 break;
1833
1834         case kEplNmtCsNotActive:
1835         case kEplNmtCsPreOperational1:
1836                 // reduced EPL cycle is active
1837                 if (NmtEvent_p == kEplNmtEventDllCeSoc) {       // SoC received
1838                         // enter DLL_CS_WAIT_PREQ
1839                         EplDllkInstance_g.m_DllState = kEplDllCsWaitPreq;
1840                 } else {
1841                         // enter DLL_GS_INIT
1842                         EplDllkInstance_g.m_DllState = kEplDllGsInit;
1843                 }
1844                 break;
1845
1846         case kEplNmtCsPreOperational2:
1847         case kEplNmtCsReadyToOperate:
1848         case kEplNmtCsOperational:
1849                 // full EPL cycle is active
1850
1851                 switch (EplDllkInstance_g.m_DllState) {
1852                 case kEplDllCsWaitPreq:
1853                         switch (NmtEvent_p) {
1854                                 // DLL_CT2
1855                         case kEplNmtEventDllCePreq:
1856                                 // enter DLL_CS_WAIT_SOA
1857                                 DllEvent.m_ulDllErrorEvents |=
1858                                     EPL_DLL_ERR_CN_RECVD_PREQ;
1859                                 EplDllkInstance_g.m_DllState = kEplDllCsWaitSoa;
1860                                 break;
1861
1862                                 // DLL_CT8
1863                         case kEplNmtEventDllCeFrameTimeout:
1864                                 if (NmtState_p == kEplNmtCsPreOperational2) {   // ignore frame timeout in PreOp2,
1865                                         // because the previously configured cycle len
1866                                         // may be wrong.
1867                                         // 2008/10/15 d.k. If it would not be ignored,
1868                                         // we would go cyclically to PreOp1 and on next
1869                                         // SoC back to PreOp2.
1870                                         break;
1871                                 }
1872                                 // report DLL_CEV_LOSS_SOC and DLL_CEV_LOSS_SOA
1873                                 DllEvent.m_ulDllErrorEvents |=
1874                                     EPL_DLL_ERR_CN_LOSS_SOA |
1875                                     EPL_DLL_ERR_CN_LOSS_SOC;
1876
1877                                 // enter DLL_CS_WAIT_SOC
1878                                 EplDllkInstance_g.m_DllState = kEplDllCsWaitSoc;
1879                                 break;
1880
1881                         case kEplNmtEventDllCeSoa:
1882                                 // check if multiplexed and PReq should have been received in this cycle
1883                                 // and if >= NMT_CS_READY_TO_OPERATE
1884                                 if ((EplDllkInstance_g.m_uiCycleCount == 0)
1885                                     && (NmtState_p >= kEplNmtCsReadyToOperate)) {       // report DLL_CEV_LOSS_OF_PREQ
1886                                         DllEvent.m_ulDllErrorEvents |=
1887                                             EPL_DLL_ERR_CN_LOSS_PREQ;
1888                                 }
1889                                 // enter DLL_CS_WAIT_SOC
1890                                 EplDllkInstance_g.m_DllState = kEplDllCsWaitSoc;
1891                                 break;
1892
1893                                 // DLL_CT7
1894                         case kEplNmtEventDllCeSoc:
1895                         case kEplNmtEventDllCeAsnd:
1896                                 // report DLL_CEV_LOSS_SOA
1897                                 DllEvent.m_ulDllErrorEvents |=
1898                                     EPL_DLL_ERR_CN_LOSS_SOA;
1899
1900                         case kEplNmtEventDllCePres:
1901                         default:
1902                                 // remain in this state
1903                                 break;
1904                         }
1905                         break;
1906
1907                 case kEplDllCsWaitSoc:
1908                         switch (NmtEvent_p) {
1909                                 // DLL_CT1
1910                         case kEplNmtEventDllCeSoc:
1911                                 // start of cycle and isochronous phase
1912                                 // enter DLL_CS_WAIT_PREQ
1913                                 EplDllkInstance_g.m_DllState =
1914                                     kEplDllCsWaitPreq;
1915                                 break;
1916
1917                                 // DLL_CT4
1918 //                        case kEplNmtEventDllCePres:
1919                         case kEplNmtEventDllCeFrameTimeout:
1920                                 if (NmtState_p == kEplNmtCsPreOperational2) {   // ignore frame timeout in PreOp2,
1921                                         // because the previously configured cycle len
1922                                         // may be wrong.
1923                                         // 2008/10/15 d.k. If it would not be ignored,
1924                                         // we would go cyclically to PreOp1 and on next
1925                                         // SoC back to PreOp2.
1926                                         break;
1927                                 }
1928                                 // fall through
1929
1930                         case kEplNmtEventDllCePreq:
1931                         case kEplNmtEventDllCeSoa:
1932                                 // report DLL_CEV_LOSS_SOC
1933                                 DllEvent.m_ulDllErrorEvents |=
1934                                     EPL_DLL_ERR_CN_LOSS_SOC;
1935
1936                         case kEplNmtEventDllCeAsnd:
1937                         default:
1938                                 // remain in this state
1939                                 break;
1940                         }
1941                         break;
1942
1943                 case kEplDllCsWaitSoa:
1944                         switch (NmtEvent_p) {
1945                         case kEplNmtEventDllCeFrameTimeout:
1946                                 // DLL_CT3
1947                                 if (NmtState_p == kEplNmtCsPreOperational2) {   // ignore frame timeout in PreOp2,
1948                                         // because the previously configured cycle len
1949                                         // may be wrong.
1950                                         // 2008/10/15 d.k. If it would not be ignored,
1951                                         // we would go cyclically to PreOp1 and on next
1952                                         // SoC back to PreOp2.
1953                                         break;
1954                                 }
1955                                 // fall through
1956
1957                         case kEplNmtEventDllCePreq:
1958                                 // report DLL_CEV_LOSS_SOC and DLL_CEV_LOSS_SOA
1959                                 DllEvent.m_ulDllErrorEvents |=
1960                                     EPL_DLL_ERR_CN_LOSS_SOA |
1961                                     EPL_DLL_ERR_CN_LOSS_SOC;
1962
1963                         case kEplNmtEventDllCeSoa:
1964                                 // enter DLL_CS_WAIT_SOC
1965                                 EplDllkInstance_g.m_DllState = kEplDllCsWaitSoc;
1966                                 break;
1967
1968                                 // DLL_CT9
1969                         case kEplNmtEventDllCeSoc:
1970                                 // report DLL_CEV_LOSS_SOA
1971                                 DllEvent.m_ulDllErrorEvents |=
1972                                     EPL_DLL_ERR_CN_LOSS_SOA;
1973
1974                                 // enter DLL_CS_WAIT_PREQ
1975                                 EplDllkInstance_g.m_DllState =
1976                                     kEplDllCsWaitPreq;
1977                                 break;
1978
1979                                 // DLL_CT10
1980                         case kEplNmtEventDllCeAsnd:
1981                                 // report DLL_CEV_LOSS_SOA
1982                                 DllEvent.m_ulDllErrorEvents |=
1983                                     EPL_DLL_ERR_CN_LOSS_SOA;
1984
1985                         case kEplNmtEventDllCePres:
1986                         default:
1987                                 // remain in this state
1988                                 break;
1989                         }
1990                         break;
1991
1992                 case kEplDllGsInit:
1993                         // enter DLL_CS_WAIT_PREQ
1994                         EplDllkInstance_g.m_DllState = kEplDllCsWaitPreq;
1995                         break;
1996
1997                 default:
1998                         break;
1999                 }
2000                 break;
2001
2002         case kEplNmtCsStopped:
2003                 // full EPL cycle is active, but without PReq/PRes
2004
2005                 switch (EplDllkInstance_g.m_DllState) {
2006                 case kEplDllCsWaitPreq:
2007                         switch (NmtEvent_p) {
2008                                 // DLL_CT2
2009                         case kEplNmtEventDllCePreq:
2010                                 // enter DLL_CS_WAIT_SOA
2011                                 EplDllkInstance_g.m_DllState = kEplDllCsWaitSoa;
2012                                 break;
2013
2014                                 // DLL_CT8
2015                         case kEplNmtEventDllCeFrameTimeout:
2016                                 // report DLL_CEV_LOSS_SOC and DLL_CEV_LOSS_SOA
2017                                 DllEvent.m_ulDllErrorEvents |=
2018                                     EPL_DLL_ERR_CN_LOSS_SOA |
2019                                     EPL_DLL_ERR_CN_LOSS_SOC;
2020
2021                         case kEplNmtEventDllCeSoa:
2022                                 // NMT_CS_STOPPED active
2023                                 // it is Ok if no PReq was received
2024
2025                                 // enter DLL_CS_WAIT_SOC
2026                                 EplDllkInstance_g.m_DllState = kEplDllCsWaitSoc;
2027                                 break;
2028
2029                                 // DLL_CT7
2030                         case kEplNmtEventDllCeSoc:
2031                         case kEplNmtEventDllCeAsnd:
2032                                 // report DLL_CEV_LOSS_SOA
2033                                 DllEvent.m_ulDllErrorEvents |=
2034                                     EPL_DLL_ERR_CN_LOSS_SOA;
2035
2036                         case kEplNmtEventDllCePres:
2037                         default:
2038                                 // remain in this state
2039                                 break;
2040                         }
2041                         break;
2042
2043                 case kEplDllCsWaitSoc:
2044                         switch (NmtEvent_p) {
2045                                 // DLL_CT1
2046                         case kEplNmtEventDllCeSoc:
2047                                 // start of cycle and isochronous phase
2048                                 // enter DLL_CS_WAIT_SOA
2049                                 EplDllkInstance_g.m_DllState = kEplDllCsWaitSoa;
2050                                 break;
2051
2052                                 // DLL_CT4
2053 //                        case kEplNmtEventDllCePres:
2054                         case kEplNmtEventDllCePreq:
2055                         case kEplNmtEventDllCeSoa:
2056                         case kEplNmtEventDllCeFrameTimeout:
2057                                 // report DLL_CEV_LOSS_SOC
2058                                 DllEvent.m_ulDllErrorEvents |=
2059                                     EPL_DLL_ERR_CN_LOSS_SOC;
2060
2061                         case kEplNmtEventDllCeAsnd:
2062                         default:
2063                                 // remain in this state
2064                                 break;
2065                         }
2066                         break;
2067
2068                 case kEplDllCsWaitSoa:
2069                         switch (NmtEvent_p) {
2070                                 // DLL_CT3
2071                         case kEplNmtEventDllCeFrameTimeout:
2072                                 // report DLL_CEV_LOSS_SOC and DLL_CEV_LOSS_SOA
2073                                 DllEvent.m_ulDllErrorEvents |=
2074                                     EPL_DLL_ERR_CN_LOSS_SOA |
2075                                     EPL_DLL_ERR_CN_LOSS_SOC;
2076
2077                         case kEplNmtEventDllCeSoa:
2078                                 // enter DLL_CS_WAIT_SOC
2079                                 EplDllkInstance_g.m_DllState = kEplDllCsWaitSoc;
2080                                 break;
2081
2082                                 // DLL_CT9
2083                         case kEplNmtEventDllCeSoc:
2084                                 // report DLL_CEV_LOSS_SOA
2085                                 DllEvent.m_ulDllErrorEvents |=
2086                                     EPL_DLL_ERR_CN_LOSS_SOA;
2087                                 // remain in DLL_CS_WAIT_SOA
2088                                 break;
2089
2090                                 // DLL_CT10
2091                         case kEplNmtEventDllCeAsnd:
2092                                 // report DLL_CEV_LOSS_SOA
2093                                 DllEvent.m_ulDllErrorEvents |=
2094                                     EPL_DLL_ERR_CN_LOSS_SOA;
2095
2096                         case kEplNmtEventDllCePreq:
2097                                 // NMT_CS_STOPPED active and we do not expect any PReq
2098                                 // so just ignore it
2099                         case kEplNmtEventDllCePres:
2100                         default:
2101                                 // remain in this state
2102                                 break;
2103                         }
2104                         break;
2105
2106                 case kEplDllGsInit:
2107                 default:
2108                         // enter DLL_CS_WAIT_PREQ
2109                         EplDllkInstance_g.m_DllState = kEplDllCsWaitSoa;
2110                         break;
2111                 }
2112                 break;
2113
2114 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
2115         case kEplNmtMsNotActive:
2116         case kEplNmtMsBasicEthernet:
2117                 break;
2118
2119         case kEplNmtMsPreOperational1:
2120                 // reduced EPL cycle is active
2121                 if (EplDllkInstance_g.m_DllState != kEplDllMsNonCyclic) {       // stop cycle timer
2122 #if EPL_TIMER_USE_HIGHRES != FALSE
2123                         Ret =
2124                             EplTimerHighReskDeleteTimer(&EplDllkInstance_g.
2125                                                         m_TimerHdlCycle);
2126 #endif
2127                         EplDllkInstance_g.m_DllState = kEplDllMsNonCyclic;
2128
2129                         // stop further processing,
2130                         // because it will be restarted by NMT MN module
2131                         break;
2132                 }
2133
2134                 switch (NmtEvent_p) {
2135                 case kEplNmtEventDllMeSocTrig:
2136                 case kEplNmtEventDllCeAsnd:
2137                         {       // because of reduced EPL cycle SoA shall be triggered, not SoC
2138                                 tEplDllState DummyDllState;
2139
2140                                 Ret =
2141                                     EplDllkAsyncFrameNotReceived
2142                                     (EplDllkInstance_g.m_LastReqServiceId,
2143                                      EplDllkInstance_g.m_uiLastTargetNodeId);
2144
2145                                 // go ahead and send SoA
2146                                 Ret = EplDllkMnSendSoa(NmtState_p,
2147                                                        &DummyDllState,
2148                                                        (EplDllkInstance_g.
2149                                                         m_uiCycleCount >=
2150                                                         EPL_C_DLL_PREOP1_START_CYCLES));
2151                                 // increment cycle counter to detect if EPL_C_DLL_PREOP1_START_CYCLES empty cycles are elapsed
2152                                 EplDllkInstance_g.m_uiCycleCount++;
2153
2154                                 // reprogram timer
2155 #if EPL_TIMER_USE_HIGHRES != FALSE
2156                                 if (EplDllkInstance_g.m_DllConfigParam.
2157                                     m_dwAsyncSlotTimeout != 0) {
2158                                         Ret =
2159                                             EplTimerHighReskModifyTimerNs
2160                                             (&EplDllkInstance_g.m_TimerHdlCycle,
2161                                              EplDllkInstance_g.m_DllConfigParam.
2162                                              m_dwAsyncSlotTimeout,
2163                                              EplDllkCbMnTimerCycle, 0L, FALSE);
2164                                 }
2165 #endif
2166                                 break;
2167                         }
2168
2169                 default:
2170                         break;
2171                 }
2172                 break;
2173
2174         case kEplNmtMsPreOperational2:
2175         case kEplNmtMsReadyToOperate:
2176         case kEplNmtMsOperational:
2177                 // full EPL cycle is active
2178                 switch (NmtEvent_p) {
2179                 case kEplNmtEventDllMeSocTrig:
2180                         {
2181                                 // update cycle counter
2182                                 if (EplDllkInstance_g.m_DllConfigParam.m_uiMultiplCycleCnt > 0) {       // multiplexed cycle active
2183                                         EplDllkInstance_g.m_uiCycleCount =
2184                                             (EplDllkInstance_g.m_uiCycleCount +
2185                                              1) %
2186                                             EplDllkInstance_g.m_DllConfigParam.
2187                                             m_uiMultiplCycleCnt;
2188                                         // $$$ check multiplexed cycle restart
2189                                         //     -> toggle MC flag
2190                                         //     -> change node linked list
2191                                 } else {        // non-multiplexed cycle active
2192                                         // start with first node in isochronous phase
2193                                         EplDllkInstance_g.m_pCurNodeInfo = NULL;
2194                                 }
2195
2196                                 switch (EplDllkInstance_g.m_DllState) {
2197                                 case kEplDllMsNonCyclic:
2198                                         {       // start continuous cycle timer
2199 #if EPL_TIMER_USE_HIGHRES != FALSE
2200                                                 Ret =
2201                                                     EplTimerHighReskModifyTimerNs
2202                                                     (&EplDllkInstance_g.
2203                                                      m_TimerHdlCycle,
2204                                                      EplDllkInstance_g.
2205                                                      m_ullFrameTimeout,
2206                                                      EplDllkCbMnTimerCycle, 0L,
2207                                                      TRUE);
2208 #endif
2209                                                 // continue with sending SoC
2210                                         }
2211
2212                                 case kEplDllMsWaitAsnd:
2213                                 case kEplDllMsWaitSocTrig:
2214                                         {       // if m_LastReqServiceId is still valid,
2215                                                 // SoA was not correctly answered
2216                                                 // and user part has to be informed
2217                                                 Ret =
2218                                                     EplDllkAsyncFrameNotReceived
2219                                                     (EplDllkInstance_g.
2220                                                      m_LastReqServiceId,
2221                                                      EplDllkInstance_g.
2222                                                      m_uiLastTargetNodeId);
2223
2224                                                 // send SoC
2225                                                 Ret = EplDllkMnSendSoc();
2226
2227                                                 // new DLL state
2228                                                 EplDllkInstance_g.m_DllState =
2229                                                     kEplDllMsWaitPreqTrig;
2230
2231                                                 // start WaitSoCPReq Timer
2232 #if EPL_TIMER_USE_HIGHRES != FALSE
2233                                                 Ret =
2234                                                     EplTimerHighReskModifyTimerNs
2235                                                     (&EplDllkInstance_g.
2236                                                      m_TimerHdlResponse,
2237                                                      EplDllkInstance_g.
2238                                                      m_DllConfigParam.
2239                                                      m_dwWaitSocPreq,
2240                                                      EplDllkCbMnTimerResponse,
2241                                                      0L, FALSE);
2242 #endif
2243                                                 break;
2244                                         }
2245
2246                                 default:
2247                                         {       // wrong DLL state / cycle time exceeded
2248                                                 DllEvent.m_ulDllErrorEvents |=
2249                                                     EPL_DLL_ERR_MN_CYCTIMEEXCEED;
2250                                                 EplDllkInstance_g.m_DllState =
2251                                                     kEplDllMsWaitSocTrig;
2252                                                 break;
2253                                         }
2254                                 }
2255
2256                                 break;
2257                         }
2258
2259                 case kEplNmtEventDllMePresTimeout:
2260                         {
2261
2262                                 switch (EplDllkInstance_g.m_DllState) {
2263                                 case kEplDllMsWaitPres:
2264                                         {       // PRes not received
2265
2266                                                 if (EplDllkInstance_g.m_pCurNodeInfo->m_fSoftDelete == FALSE) { // normal isochronous CN
2267                                                         DllEvent.
2268                                                             m_ulDllErrorEvents
2269                                                             |=
2270                                                             EPL_DLL_ERR_MN_CN_LOSS_PRES;
2271                                                         DllEvent.m_uiNodeId =
2272                                                             EplDllkInstance_g.
2273                                                             m_pCurNodeInfo->
2274                                                             m_uiNodeId;
2275                                                 } else {        // CN shall be deleted softly
2276                                                         Event.m_EventSink =
2277                                                             kEplEventSinkDllkCal;
2278                                                         Event.m_EventType =
2279                                                             kEplEventTypeDllkSoftDelNode;
2280                                                         // $$$ d.k. set Event.m_NetTime to current time
2281                                                         Event.m_uiSize =
2282                                                             sizeof(unsigned
2283                                                                    int);
2284                                                         Event.m_pArg =
2285                                                             &EplDllkInstance_g.
2286                                                             m_pCurNodeInfo->
2287                                                             m_uiNodeId;
2288                                                         Ret =
2289                                                             EplEventkPost
2290                                                             (&Event);
2291                                                 }
2292
2293                                                 // continue with sending next PReq
2294                                         }
2295
2296                                 case kEplDllMsWaitPreqTrig:
2297                                         {
2298                                                 // send next PReq
2299                                                 Ret =
2300                                                     EplDllkMnSendPreq
2301                                                     (NmtState_p,
2302                                                      &EplDllkInstance_g.
2303                                                      m_DllState);
2304
2305                                                 break;
2306                                         }
2307
2308                                 default:
2309                                         {       // wrong DLL state
2310                                                 break;
2311                                         }
2312                                 }
2313
2314                                 break;
2315                         }
2316
2317                 case kEplNmtEventDllCePres:
2318                         {
2319
2320                                 switch (EplDllkInstance_g.m_DllState) {
2321                                 case kEplDllMsWaitPres:
2322                                         {       // PRes received
2323                                                 // send next PReq
2324                                                 Ret =
2325                                                     EplDllkMnSendPreq
2326                                                     (NmtState_p,
2327                                                      &EplDllkInstance_g.
2328                                                      m_DllState);
2329
2330                                                 break;
2331                                         }
2332
2333                                 default:
2334                                         {       // wrong DLL state
2335                                                 break;
2336                                         }
2337                                 }
2338
2339                                 break;
2340                         }
2341
2342                 case kEplNmtEventDllMeSoaTrig:
2343                         {
2344
2345                                 switch (EplDllkInstance_g.m_DllState) {
2346                                 case kEplDllMsWaitSoaTrig:
2347                                         {       // MN PRes sent
2348                                                 // send SoA
2349                                                 Ret =
2350                                                     EplDllkMnSendSoa(NmtState_p,
2351                                                                      &EplDllkInstance_g.
2352                                                                      m_DllState,
2353                                                                      TRUE);
2354
2355                                                 break;
2356                                         }
2357
2358                                 default:
2359                                         {       // wrong DLL state
2360                                                 break;
2361                                         }
2362                                 }
2363
2364                                 break;
2365                         }
2366
2367                 case kEplNmtEventDllCeAsnd:
2368                         {       // ASnd has been received, but it may be not the requested one
2369 /*
2370                     // report if SoA was correctly answered
2371                     Ret = EplDllkAsyncFrameNotReceived(EplDllkInstance_g.m_LastReqServiceId,
2372                                                        EplDllkInstance_g.m_uiLastTargetNodeId);
2373 */
2374                                 if (EplDllkInstance_g.m_DllState ==
2375                                     kEplDllMsWaitAsnd) {
2376                                         EplDllkInstance_g.m_DllState =
2377                                             kEplDllMsWaitSocTrig;
2378                                 }
2379                                 break;
2380                         }
2381
2382                 default:
2383                         break;
2384                 }
2385                 break;
2386 #endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
2387
2388         default:
2389                 break;
2390         }
2391
2392         if (DllEvent.m_ulDllErrorEvents != 0) { // error event set -> post it to error handler
2393                 Event.m_EventSink = kEplEventSinkErrk;
2394                 Event.m_EventType = kEplEventTypeDllError;
2395                 // $$$ d.k. set Event.m_NetTime to current time
2396                 Event.m_uiSize = sizeof(DllEvent);
2397                 Event.m_pArg = &DllEvent;
2398                 Ret = EplEventkPost(&Event);
2399         }
2400
2401         return Ret;
2402 }
2403
2404 //---------------------------------------------------------------------------
2405 //
2406 // Function:    EplDllkCbFrameReceived()
2407 //
2408 // Description: called from EdrvInterruptHandler()
2409 //
2410 // Parameters:  pRxBuffer_p             = receive buffer structure
2411 //
2412 // Returns:     (none)
2413 //
2414 //
2415 // State:
2416 //
2417 //---------------------------------------------------------------------------
2418
2419 static void EplDllkCbFrameReceived(tEdrvRxBuffer * pRxBuffer_p)
2420 {
2421         tEplKernel Ret = kEplSuccessful;
2422         tEplNmtState NmtState;
2423         tEplNmtEvent NmtEvent = kEplNmtEventNoEvent;
2424         tEplEvent Event;
2425         tEplFrame *pFrame;
2426         tEplFrame *pTxFrame;
2427         tEdrvTxBuffer *pTxBuffer = NULL;
2428         tEplFrameInfo FrameInfo;
2429         tEplMsgType MsgType;
2430         tEplDllReqServiceId ReqServiceId;
2431         unsigned int uiAsndServiceId;
2432         unsigned int uiNodeId;
2433         u8 bFlag1;
2434
2435         BENCHMARK_MOD_02_SET(3);
2436         NmtState = EplNmtkGetNmtState();
2437
2438         if (NmtState <= kEplNmtGsResetConfiguration) {
2439                 goto Exit;
2440         }
2441
2442         pFrame = (tEplFrame *) pRxBuffer_p->m_pbBuffer;
2443
2444 #if EDRV_EARLY_RX_INT != FALSE
2445         switch (pRxBuffer_p->m_BufferInFrame) {
2446         case kEdrvBufferFirstInFrame:
2447                 {
2448                         MsgType =
2449                             (tEplMsgType) AmiGetByteFromLe(&pFrame->
2450                                                            m_le_bMessageType);
2451                         if (MsgType == kEplMsgTypePreq) {
2452                                 if (EplDllkInstance_g.m_DllState == kEplDllCsWaitPreq) {        // PReq expected and actually received
2453                                         // d.k.: The condition above is sufficent, because EPL cycle is active
2454                                         //       and no non-EPL frame shall be received in isochronous phase.
2455                                         // start transmission PRes
2456                                         // $$$ What if Tx buffer is invalid?
2457                                         pTxBuffer =
2458                                             &EplDllkInstance_g.
2459                                             m_pTxBuffer[EPL_DLLK_TXFRAME_PRES];
2460 #if (EPL_DLL_PRES_READY_AFTER_SOA != FALSE) || (EPL_DLL_PRES_READY_AFTER_SOC != FALSE)
2461                                         Ret = EdrvTxMsgStart(pTxBuffer);
2462 #else
2463                                         pTxFrame =
2464                                             (tEplFrame *) pTxBuffer->m_pbBuffer;
2465                                         // update frame (NMT state, RD, RS, PR, MS, EN flags)
2466                                         AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.
2467                                                        m_le_bNmtStatus,
2468                                                        (u8) NmtState);
2469                                         AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.
2470                                                        m_le_bFlag2,
2471                                                        EplDllkInstance_g.
2472                                                        m_bFlag2);
2473                                         if (NmtState != kEplNmtCsOperational) { // mark PDO as invalid in NMT state Op
2474                                                 // $$$ reset only RD flag; set other flags appropriately
2475                                                 AmiSetByteToLe(&pTxFrame->
2476                                                                m_Data.m_Pres.
2477                                                                m_le_bFlag1, 0);
2478                                         }
2479                                         // $$$ make function that updates Pres, StatusRes
2480                                         // send PRes frame
2481                                         Ret = EdrvSendTxMsg(pTxBuffer);
2482 #endif
2483                                 }
2484                         }
2485                         goto Exit;
2486                 }
2487
2488         case kEdrvBufferMiddleInFrame:
2489                 {
2490                         goto Exit;
2491                 }
2492
2493         case kEdrvBufferLastInFrame:
2494                 {
2495                         break;
2496                 }
2497         }
2498 #endif
2499
2500         FrameInfo.m_pFrame = pFrame;
2501         FrameInfo.m_uiFrameSize = pRxBuffer_p->m_uiRxMsgLen;
2502         FrameInfo.m_NetTime.m_dwNanoSec = pRxBuffer_p->m_NetTime.m_dwNanoSec;
2503         FrameInfo.m_NetTime.m_dwSec = pRxBuffer_p->m_NetTime.m_dwSec;
2504
2505         if (AmiGetWordFromBe(&pFrame->m_be_wEtherType) != EPL_C_DLL_ETHERTYPE_EPL) {    // non-EPL frame
2506                 //TRACE2("EplDllkCbFrameReceived: pfnCbAsync=0x%p SrcMAC=0x%llx\n", EplDllkInstance_g.m_pfnCbAsync, AmiGetQword48FromBe(pFrame->m_be_abSrcMac));
2507                 if (EplDllkInstance_g.m_pfnCbAsync != NULL) {   // handler for async frames is registered
2508                         EplDllkInstance_g.m_pfnCbAsync(&FrameInfo);
2509                 }
2510
2511                 goto Exit;
2512         }
2513
2514         MsgType = (tEplMsgType) AmiGetByteFromLe(&pFrame->m_le_bMessageType);
2515         switch (MsgType) {
2516         case kEplMsgTypePreq:
2517                 {
2518                         // PReq frame
2519                         // d.k.: (we assume that this PReq frame is intended for us and don't check DstNodeId)
2520                         if (AmiGetByteFromLe(&pFrame->m_le_bDstNodeId) != EplDllkInstance_g.m_DllConfigParam.m_uiNodeId) {      // this PReq is not intended for us
2521                                 goto Exit;
2522                         }
2523                         NmtEvent = kEplNmtEventDllCePreq;
2524
2525                         if (NmtState >= kEplNmtMsNotActive) {   // MN is active -> wrong msg type
2526                                 break;
2527                         }
2528 #if EDRV_EARLY_RX_INT == FALSE
2529                         if (NmtState >= kEplNmtCsPreOperational2) {     // respond to and process PReq frames only in PreOp2, ReadyToOp and Op
2530                                 // Does PRes exist?
2531                                 pTxBuffer =
2532                                     &EplDllkInstance_g.
2533                                     m_pTxBuffer[EPL_DLLK_TXFRAME_PRES];
2534                                 if (pTxBuffer->m_pbBuffer != NULL) {    // PRes does exist
2535 #if (EPL_DLL_PRES_READY_AFTER_SOA != FALSE) || (EPL_DLL_PRES_READY_AFTER_SOC != FALSE)
2536                                         EdrvTxMsgStart(pTxBuffer);
2537 #else
2538                                         pTxFrame =
2539                                             (tEplFrame *) pTxBuffer->m_pbBuffer;
2540                                         // update frame (NMT state, RD, RS, PR, MS, EN flags)
2541                                         AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.
2542                                                        m_le_bNmtStatus,
2543                                                        (u8) NmtState);
2544                                         AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.
2545                                                        m_le_bFlag2,
2546                                                        EplDllkInstance_g.
2547                                                        m_bFlag2);
2548                                         bFlag1 =
2549                                             AmiGetByteFromLe(&pFrame->m_Data.
2550                                                              m_Preq.
2551                                                              m_le_bFlag1);
2552                                         // save EA flag
2553                                         EplDllkInstance_g.m_bMnFlag1 =
2554                                             (EplDllkInstance_g.
2555                                              m_bMnFlag1 & ~EPL_FRAME_FLAG1_EA)
2556                                             | (bFlag1 & EPL_FRAME_FLAG1_EA);
2557                                         // preserve MS flag
2558                                         bFlag1 &= EPL_FRAME_FLAG1_MS;
2559                                         // add EN flag from Error signaling module
2560                                         bFlag1 |=
2561                                             EplDllkInstance_g.
2562                                             m_bFlag1 & EPL_FRAME_FLAG1_EN;
2563                                         if (NmtState != kEplNmtCsOperational) { // mark PDO as invalid in NMT state Op
2564                                                 // reset only RD flag
2565                                                 AmiSetByteToLe(&pTxFrame->
2566                                                                m_Data.m_Pres.
2567                                                                m_le_bFlag1,
2568                                                                bFlag1);
2569                                         } else {        // leave RD flag untouched
2570                                                 AmiSetByteToLe(&pTxFrame->
2571                                                                m_Data.m_Pres.
2572                                                                m_le_bFlag1,
2573                                                                (AmiGetByteFromLe
2574                                                                 (&pTxFrame->
2575                                                                  m_Data.m_Pres.
2576                                                                  m_le_bFlag1) &
2577                                                                 EPL_FRAME_FLAG1_RD)
2578                                                                | bFlag1);
2579                                         }
2580                                         // $$$ update EPL_DLL_PRES_READY_AFTER_* code
2581                                         // send PRes frame
2582                                         Ret = EdrvSendTxMsg(pTxBuffer);
2583                                         if (Ret != kEplSuccessful) {
2584                                                 goto Exit;
2585                                         }
2586 #endif
2587                                 }
2588 #endif
2589                                 // inform PDO module
2590 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
2591                                 if (NmtState >= kEplNmtCsReadyToOperate) {      // inform PDO module only in ReadyToOp and Op
2592                                         if (NmtState != kEplNmtCsOperational) {
2593                                                 // reset RD flag and all other flags, but that does not matter, because they were processed above
2594                                                 AmiSetByteToLe(&pFrame->m_Data.
2595                                                                m_Preq.
2596                                                                m_le_bFlag1, 0);
2597                                         }
2598                                         // compares real frame size and PDO size
2599                                         if ((unsigned
2600                                              int)(AmiGetWordFromLe(&pFrame->
2601                                                                    m_Data.
2602                                                                    m_Preq.
2603                                                                    m_le_wSize) +
2604                                                   24)
2605                                             > FrameInfo.m_uiFrameSize) {        // format error
2606                                                 tEplErrorHandlerkEvent DllEvent;
2607
2608                                                 DllEvent.m_ulDllErrorEvents =
2609                                                     EPL_DLL_ERR_INVALID_FORMAT;
2610                                                 DllEvent.m_uiNodeId =
2611                                                     AmiGetByteFromLe(&pFrame->
2612                                                                      m_le_bSrcNodeId);
2613                                                 DllEvent.m_NmtState = NmtState;
2614                                                 Event.m_EventSink =
2615                                                     kEplEventSinkErrk;
2616                                                 Event.m_EventType =
2617                                                     kEplEventTypeDllError;
2618                                                 Event.m_NetTime =
2619                                                     FrameInfo.m_NetTime;
2620                                                 Event.m_uiSize =
2621                                                     sizeof(DllEvent);
2622                                                 Event.m_pArg = &DllEvent;
2623                                                 Ret = EplEventkPost(&Event);
2624                                                 break;
2625                                         }
2626                                         // forward PReq frame as RPDO to PDO module
2627                                         Ret = EplPdokCbPdoReceived(&FrameInfo);
2628
2629                                 }
2630 #if (EPL_DLL_PRES_READY_AFTER_SOC != FALSE)
2631                                 if (pTxBuffer->m_pbBuffer != NULL) {    // PRes does exist
2632                                         // inform PDO module about PRes after PReq
2633                                         FrameInfo.m_pFrame =
2634                                             (tEplFrame *) pTxBuffer->m_pbBuffer;
2635                                         FrameInfo.m_uiFrameSize =
2636                                             pTxBuffer->m_uiMaxBufferLen;
2637                                         Ret =
2638                                             EplPdokCbPdoTransmitted(&FrameInfo);
2639                                 }
2640 #endif
2641 #endif
2642
2643 #if EDRV_EARLY_RX_INT == FALSE
2644                                 // $$$ inform emergency protocol handling (error signaling module) about flags
2645                         }
2646 #endif
2647
2648                         // reset cycle counter
2649                         EplDllkInstance_g.m_uiCycleCount = 0;
2650
2651                         break;
2652                 }
2653
2654         case kEplMsgTypePres:
2655                 {
2656 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
2657                         tEplDllkNodeInfo *pIntNodeInfo;
2658                         tEplHeartbeatEvent HeartbeatEvent;
2659 #endif
2660
2661                         // PRes frame
2662                         NmtEvent = kEplNmtEventDllCePres;
2663
2664                         uiNodeId = AmiGetByteFromLe(&pFrame->m_le_bSrcNodeId);
2665
2666                         if ((NmtState >= kEplNmtCsPreOperational2)
2667                             && (NmtState <= kEplNmtCsOperational)) {    // process PRes frames only in PreOp2, ReadyToOp and Op of CN
2668
2669 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
2670                                 pIntNodeInfo = EplDllkGetNodeInfo(uiNodeId);
2671                                 if (pIntNodeInfo == NULL) {     // no node info structure available
2672                                         Ret = kEplDllNoNodeInfo;
2673                                         goto Exit;
2674                                 }
2675                         } else if (EplDllkInstance_g.m_DllState == kEplDllMsWaitPres) { // or process PRes frames in MsWaitPres
2676
2677                                 pIntNodeInfo = EplDllkInstance_g.m_pCurNodeInfo;
2678                                 if ((pIntNodeInfo == NULL) || (pIntNodeInfo->m_uiNodeId != uiNodeId)) { // ignore PRes, because it is from wrong CN
2679                                         // $$$ maybe post event to NmtMn module
2680                                         goto Exit;
2681                                 }
2682                                 // forward Flag2 to asynchronous scheduler
2683                                 bFlag1 =
2684                                     AmiGetByteFromLe(&pFrame->m_Data.m_Asnd.
2685                                                      m_Payload.m_StatusResponse.
2686                                                      m_le_bFlag2);
2687                                 Ret =
2688                                     EplDllkCalAsyncSetPendingRequests(uiNodeId,
2689                                                                       ((tEplDllAsyncReqPriority) ((bFlag1 & EPL_FRAME_FLAG2_PR) >> EPL_FRAME_FLAG2_PR_SHIFT)), (bFlag1 & EPL_FRAME_FLAG2_RS));
2690
2691 #endif
2692                         } else {        // ignore PRes, because it was received in wrong NMT state
2693                                 // but execute EplDllkChangeState() and post event to NMT module
2694                                 break;
2695                         }
2696
2697 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
2698                         {       // check NMT state of CN
2699                                 HeartbeatEvent.m_wErrorCode = EPL_E_NO_ERROR;
2700                                 HeartbeatEvent.m_NmtState =
2701                                     (tEplNmtState) (AmiGetByteFromLe
2702                                                     (&pFrame->m_Data.m_Pres.
2703                                                      m_le_bNmtStatus) |
2704                                                     EPL_NMT_TYPE_CS);
2705                                 if (pIntNodeInfo->m_NmtState != HeartbeatEvent.m_NmtState) {    // NMT state of CN has changed -> post event to NmtMnu module
2706                                         if (pIntNodeInfo->m_fSoftDelete == FALSE) {     // normal isochronous CN
2707                                                 HeartbeatEvent.m_uiNodeId =
2708                                                     uiNodeId;
2709                                                 Event.m_EventSink =
2710                                                     kEplEventSinkNmtMnu;
2711                                                 Event.m_EventType =
2712                                                     kEplEventTypeHeartbeat;
2713                                                 Event.m_uiSize =
2714                                                     sizeof(HeartbeatEvent);
2715                                                 Event.m_pArg = &HeartbeatEvent;
2716                                         } else {        // CN shall be deleted softly
2717                                                 Event.m_EventSink =
2718                                                     kEplEventSinkDllkCal;
2719                                                 Event.m_EventType =
2720                                                     kEplEventTypeDllkSoftDelNode;
2721                                                 Event.m_uiSize =
2722                                                     sizeof(unsigned int);
2723                                                 Event.m_pArg =
2724                                                     &pIntNodeInfo->m_uiNodeId;
2725                                         }
2726                                         Event.m_NetTime = FrameInfo.m_NetTime;
2727                                         Ret = EplEventkPost(&Event);
2728
2729                                         // save current NMT state of CN in internal node structure
2730                                         pIntNodeInfo->m_NmtState =
2731                                             HeartbeatEvent.m_NmtState;
2732                                 }
2733                         }
2734 #endif
2735
2736                         // inform PDO module
2737 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
2738                         if ((NmtState != kEplNmtCsPreOperational2)
2739                             && (NmtState != kEplNmtMsPreOperational2)) {        // inform PDO module only in ReadyToOp and Op
2740                                 // compare real frame size and PDO size?
2741                                 if (((unsigned
2742                                       int)(AmiGetWordFromLe(&pFrame->m_Data.
2743                                                             m_Pres.m_le_wSize) +
2744                                            24)
2745                                      > FrameInfo.m_uiFrameSize)
2746 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
2747                                     ||
2748                                     (AmiGetWordFromLe
2749                                      (&pFrame->m_Data.m_Pres.m_le_wSize) >
2750                                      pIntNodeInfo->m_wPresPayloadLimit)
2751 #endif
2752                                     ) { // format error
2753                                         tEplErrorHandlerkEvent DllEvent;
2754
2755                                         DllEvent.m_ulDllErrorEvents =
2756                                             EPL_DLL_ERR_INVALID_FORMAT;
2757                                         DllEvent.m_uiNodeId = uiNodeId;
2758                                         DllEvent.m_NmtState = NmtState;
2759                                         Event.m_EventSink = kEplEventSinkErrk;
2760                                         Event.m_EventType =
2761                                             kEplEventTypeDllError;
2762                                         Event.m_NetTime = FrameInfo.m_NetTime;
2763                                         Event.m_uiSize = sizeof(DllEvent);
2764                                         Event.m_pArg = &DllEvent;
2765                                         Ret = EplEventkPost(&Event);
2766                                         break;
2767                                 }
2768                                 if ((NmtState != kEplNmtCsOperational)
2769                                     && (NmtState != kEplNmtMsOperational)) {
2770                                         // reset RD flag and all other flags, but that does not matter, because they were processed above
2771                                         AmiSetByteToLe(&pFrame->m_Data.m_Pres.
2772                                                        m_le_bFlag1, 0);
2773                                 }
2774                                 Ret = EplPdokCbPdoReceived(&FrameInfo);
2775                         }
2776 #endif
2777
2778                         break;
2779                 }
2780
2781         case kEplMsgTypeSoc:
2782                 {
2783                         // SoC frame
2784                         NmtEvent = kEplNmtEventDllCeSoc;
2785
2786                         if (NmtState >= kEplNmtMsNotActive) {   // MN is active -> wrong msg type
2787                                 break;
2788                         }
2789 #if EPL_DLL_PRES_READY_AFTER_SOC != FALSE
2790                         // post PRes to transmit FIFO of the ethernet controller, but don't start
2791                         // transmission over bus
2792                         pTxBuffer =
2793                             &EplDllkInstance_g.
2794                             m_pTxBuffer[EPL_DLLK_TXFRAME_PRES];
2795                         // Does PRes exist?
2796                         if (pTxBuffer->m_pbBuffer != NULL) {    // PRes does exist
2797                                 pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
2798                                 // update frame (NMT state, RD, RS, PR, MS, EN flags)
2799                                 if (NmtState < kEplNmtCsPreOperational2) {      // NMT state is not PreOp2, ReadyToOp or Op
2800                                         // fake NMT state PreOp2, because PRes will be sent only in PreOp2 or greater
2801                                         NmtState = kEplNmtCsPreOperational2;
2802                                 }
2803                                 AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.
2804                                                m_le_bNmtStatus,
2805                                                (u8) NmtState);
2806                                 AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.
2807                                                m_le_bFlag2,
2808                                                EplDllkInstance_g.m_bFlag2);
2809                                 if (NmtState != kEplNmtCsOperational) { // mark PDO as invalid in NMT state Op
2810                                         // $$$ reset only RD flag; set other flags appropriately
2811                                         AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.
2812                                                        m_le_bFlag1, 0);
2813                                 }
2814                                 // $$$ make function that updates Pres, StatusRes
2815                                 // mark PRes frame as ready for transmission
2816                                 Ret = EdrvTxMsgReady(pTxBuffer);
2817                         }
2818 #endif
2819
2820                         if (NmtState >= kEplNmtCsPreOperational2) {     // SoC frames only in PreOp2, ReadyToOp and Op
2821                                 // trigger synchronous task
2822                                 Event.m_EventSink = kEplEventSinkSync;
2823                                 Event.m_EventType = kEplEventTypeSync;
2824                                 Event.m_uiSize = 0;
2825                                 Ret = EplEventkPost(&Event);
2826
2827                                 // update cycle counter
2828                                 if (EplDllkInstance_g.m_DllConfigParam.m_uiMultiplCycleCnt > 0) {       // multiplexed cycle active
2829                                         EplDllkInstance_g.m_uiCycleCount =
2830                                             (EplDllkInstance_g.m_uiCycleCount +
2831                                              1) %
2832                                             EplDllkInstance_g.m_DllConfigParam.
2833                                             m_uiMultiplCycleCnt;
2834                                 }
2835                         }
2836                         // reprogram timer
2837 #if EPL_TIMER_USE_HIGHRES != FALSE
2838                         if (EplDllkInstance_g.m_ullFrameTimeout != 0) {
2839                                 Ret =
2840                                     EplTimerHighReskModifyTimerNs
2841                                     (&EplDllkInstance_g.m_TimerHdlCycle,
2842                                      EplDllkInstance_g.m_ullFrameTimeout,
2843                                      EplDllkCbCnTimer, 0L, FALSE);
2844                         }
2845 #endif
2846
2847                         break;
2848                 }
2849
2850         case kEplMsgTypeSoa:
2851                 {
2852                         // SoA frame
2853                         NmtEvent = kEplNmtEventDllCeSoa;
2854
2855                         if (NmtState >= kEplNmtMsNotActive) {   // MN is active -> wrong msg type
2856                                 break;
2857                         }
2858
2859                         pTxFrame = NULL;
2860
2861                         if ((NmtState & EPL_NMT_SUPERSTATE_MASK) != EPL_NMT_CS_EPLMODE) {       // do not respond, if NMT state is < PreOp1 (i.e. not EPL_MODE)
2862                                 break;
2863                         }
2864                         // check TargetNodeId
2865                         uiNodeId =
2866                             AmiGetByteFromLe(&pFrame->m_Data.m_Soa.
2867                                              m_le_bReqServiceTarget);
2868                         if (uiNodeId == EplDllkInstance_g.m_DllConfigParam.m_uiNodeId) {        // local node is the target of the current request
2869
2870                                 // check ServiceId
2871                                 ReqServiceId =
2872                                     (tEplDllReqServiceId)
2873                                     AmiGetByteFromLe(&pFrame->m_Data.m_Soa.
2874                                                      m_le_bReqServiceId);
2875                                 if (ReqServiceId == kEplDllReqServiceStatus) {  // StatusRequest
2876                                         if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_STATUSRES].m_pbBuffer != NULL) {     // StatusRes does exist
2877
2878                                                 pTxFrame =
2879                                                     (tEplFrame *)
2880                                                     EplDllkInstance_g.
2881                                                     m_pTxBuffer
2882                                                     [EPL_DLLK_TXFRAME_STATUSRES].
2883                                                     m_pbBuffer;
2884                                                 // update StatusRes frame (NMT state, EN, EC, RS, PR flags)
2885                                                 AmiSetByteToLe(&pTxFrame->
2886                                                                m_Data.m_Asnd.
2887                                                                m_Payload.
2888                                                                m_StatusResponse.
2889                                                                m_le_bNmtStatus,
2890                                                                (u8) NmtState);
2891                                                 AmiSetByteToLe(&pTxFrame->
2892                                                                m_Data.m_Asnd.
2893                                                                m_Payload.
2894                                                                m_StatusResponse.
2895                                                                m_le_bFlag1,
2896                                                                EplDllkInstance_g.
2897                                                                m_bFlag1);
2898                                                 AmiSetByteToLe(&pTxFrame->
2899                                                                m_Data.m_Asnd.
2900                                                                m_Payload.
2901                                                                m_StatusResponse.
2902                                                                m_le_bFlag2,
2903                                                                EplDllkInstance_g.
2904                                                                m_bFlag2);
2905                                                 // send StatusRes
2906                                                 Ret =
2907                                                     EdrvSendTxMsg
2908                                                     (&EplDllkInstance_g.
2909                                                      m_pTxBuffer
2910                                                      [EPL_DLLK_TXFRAME_STATUSRES]);
2911                                                 if (Ret != kEplSuccessful) {
2912                                                         goto Exit;
2913                                                 }
2914                                                 TGT_DBG_SIGNAL_TRACE_POINT(8);
2915
2916                                                 // update error signaling
2917                                                 bFlag1 =
2918                                                     AmiGetByteFromLe(&pFrame->
2919                                                                      m_Data.
2920                                                                      m_Soa.
2921                                                                      m_le_bFlag1);
2922                                                 if (((bFlag1 ^ EplDllkInstance_g.m_bMnFlag1) & EPL_FRAME_FLAG1_ER) != 0) {      // exception reset flag was changed by MN
2923                                                         // assume same state for EC in next cycle (clear all other bits)
2924                                                         if ((bFlag1 &
2925                                                              EPL_FRAME_FLAG1_ER)
2926                                                             != 0) {
2927                                                                 // set EC and reset rest
2928                                                                 EplDllkInstance_g.
2929                                                                     m_bFlag1 =
2930                                                                     EPL_FRAME_FLAG1_EC;
2931                                                         } else {
2932                                                                 // reset complete flag 1 (including EC and EN)
2933                                                                 EplDllkInstance_g.
2934                                                                     m_bFlag1 =
2935                                                                     0;
2936                                                         }
2937                                                 }
2938                                                 // save flag 1 from MN for Status request response cycle
2939                                                 EplDllkInstance_g.m_bMnFlag1 =
2940                                                     bFlag1;
2941                                         }
2942                                 } else if (ReqServiceId == kEplDllReqServiceIdent) {    // IdentRequest
2943                                         if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_IDENTRES].m_pbBuffer != NULL) {      // IdentRes does exist
2944                                                 pTxFrame =
2945                                                     (tEplFrame *)
2946                                                     EplDllkInstance_g.
2947                                                     m_pTxBuffer
2948                                                     [EPL_DLLK_TXFRAME_IDENTRES].
2949                                                     m_pbBuffer;
2950                                                 // update IdentRes frame (NMT state, RS, PR flags)
2951                                                 AmiSetByteToLe(&pTxFrame->
2952                                                                m_Data.m_Asnd.
2953                                                                m_Payload.
2954                                                                m_IdentResponse.
2955                                                                m_le_bNmtStatus,
2956                                                                (u8) NmtState);
2957                                                 AmiSetByteToLe(&pTxFrame->
2958                                                                m_Data.m_Asnd.
2959                                                                m_Payload.
2960                                                                m_IdentResponse.
2961                                                                m_le_bFlag2,
2962                                                                EplDllkInstance_g.
2963                                                                m_bFlag2);
2964                                                 // send IdentRes
2965                                                 Ret =
2966                                                     EdrvSendTxMsg
2967                                                     (&EplDllkInstance_g.
2968                                                      m_pTxBuffer
2969                                                      [EPL_DLLK_TXFRAME_IDENTRES]);
2970                                                 if (Ret != kEplSuccessful) {
2971                                                         goto Exit;
2972                                                 }
2973                                                 TGT_DBG_SIGNAL_TRACE_POINT(7);
2974                                         }
2975                                 } else if (ReqServiceId == kEplDllReqServiceNmtRequest) {       // NmtRequest
2976                                         if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_pbBuffer != NULL) {        // NmtRequest does exist
2977                                                 // check if frame is not empty and not being filled
2978                                                 if (EplDllkInstance_g.
2979                                                     m_pTxBuffer
2980                                                     [EPL_DLLK_TXFRAME_NMTREQ].
2981                                                     m_uiTxMsgLen >
2982                                                     EPL_DLLK_BUFLEN_FILLING) {
2983                                                         /*if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen < EPL_DLLK_BUFLEN_MIN)
2984                                                            {   // pad frame
2985                                                            EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen = EPL_DLLK_BUFLEN_MIN;
2986                                                            } */
2987                                                         // memorize transmission
2988                                                         pTxFrame =
2989                                                             (tEplFrame *) 1;
2990                                                         // send NmtRequest
2991                                                         Ret =
2992                                                             EdrvSendTxMsg
2993                                                             (&EplDllkInstance_g.
2994                                                              m_pTxBuffer
2995                                                              [EPL_DLLK_TXFRAME_NMTREQ]);
2996                                                         if (Ret !=
2997                                                             kEplSuccessful) {
2998                                                                 goto Exit;
2999                                                         }
3000
3001                                                 }
3002                                         }
3003
3004                                 } else if (ReqServiceId == kEplDllReqServiceUnspecified) {      // unspecified invite
3005                                         if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NONEPL].m_pbBuffer != NULL) {        // non-EPL frame does exist
3006                                                 // check if frame is not empty and not being filled
3007                                                 if (EplDllkInstance_g.
3008                                                     m_pTxBuffer
3009                                                     [EPL_DLLK_TXFRAME_NONEPL].
3010                                                     m_uiTxMsgLen >
3011                                                     EPL_DLLK_BUFLEN_FILLING) {
3012                                                         /*if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen < EPL_DLLK_BUFLEN_MIN)
3013                                                            {   // pad frame
3014                                                            EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen = EPL_DLLK_BUFLEN_MIN;
3015                                                            } */
3016                                                         // memorize transmission
3017                                                         pTxFrame =
3018                                                             (tEplFrame *) 1;
3019                                                         // send non-EPL frame
3020                                                         Ret =
3021                                                             EdrvSendTxMsg
3022                                                             (&EplDllkInstance_g.
3023                                                              m_pTxBuffer
3024                                                              [EPL_DLLK_TXFRAME_NONEPL]);
3025                                                         if (Ret !=
3026                                                             kEplSuccessful) {
3027                                                                 goto Exit;
3028                                                         }
3029
3030                                                 }
3031                                         }
3032
3033                                 } else if (ReqServiceId == kEplDllReqServiceNo) {       // no async service requested -> do nothing
3034                                 }
3035                         }
3036 #if EPL_DLL_PRES_READY_AFTER_SOA != FALSE
3037                         if (pTxFrame == NULL) { // signal process function readiness of PRes frame
3038                                 Event.m_EventSink = kEplEventSinkDllk;
3039                                 Event.m_EventType = kEplEventTypeDllkPresReady;
3040                                 Event.m_uiSize = 0;
3041                                 Event.m_pArg = NULL;
3042                                 Ret = EplEventkPost(&Event);
3043                         }
3044 #endif
3045
3046                         // inform PDO module
3047 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
3048 //            Ret = EplPdokCbSoa(&FrameInfo);
3049 #endif
3050
3051                         // $$$ put SrcNodeId, NMT state and NetTime as HeartbeatEvent into eventqueue
3052
3053                         // $$$ inform emergency protocol handling about flags
3054                         break;
3055                 }
3056
3057         case kEplMsgTypeAsnd:
3058                 {
3059                         // ASnd frame
3060                         NmtEvent = kEplNmtEventDllCeAsnd;
3061
3062                         // ASnd service registered?
3063                         uiAsndServiceId =
3064                             (unsigned int)AmiGetByteFromLe(&pFrame->m_Data.
3065                                                            m_Asnd.
3066                                                            m_le_bServiceId);
3067
3068 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
3069                         if ((EplDllkInstance_g.m_DllState >= kEplDllMsNonCyclic)
3070                             &&
3071                             ((((tEplDllAsndServiceId) uiAsndServiceId) ==
3072                               kEplDllAsndStatusResponse)
3073                              || (((tEplDllAsndServiceId) uiAsndServiceId) == kEplDllAsndIdentResponse))) {      // StatusRes or IdentRes received
3074                                 uiNodeId =
3075                                     AmiGetByteFromLe(&pFrame->m_le_bSrcNodeId);
3076                                 if ((EplDllkInstance_g.m_LastReqServiceId ==
3077                                      ((tEplDllReqServiceId) uiAsndServiceId))
3078                                     && (uiNodeId == EplDllkInstance_g.m_uiLastTargetNodeId)) {  // mark request as responded
3079                                         EplDllkInstance_g.m_LastReqServiceId =
3080                                             kEplDllReqServiceNo;
3081                                 }
3082                                 if (((tEplDllAsndServiceId) uiAsndServiceId) == kEplDllAsndIdentResponse) {     // memorize MAC address of CN for PReq
3083                                         tEplDllkNodeInfo *pIntNodeInfo;
3084
3085                                         pIntNodeInfo =
3086                                             EplDllkGetNodeInfo(uiNodeId);
3087                                         if (pIntNodeInfo == NULL) {     // no node info structure available
3088                                                 Ret = kEplDllNoNodeInfo;
3089                                         } else {
3090                                                 EPL_MEMCPY(pIntNodeInfo->
3091                                                            m_be_abMacAddr,
3092                                                            pFrame->
3093                                                            m_be_abSrcMac, 6);
3094                                         }
3095                                 }
3096                                 // forward Flag2 to asynchronous scheduler
3097                                 bFlag1 =
3098                                     AmiGetByteFromLe(&pFrame->m_Data.m_Asnd.
3099                                                      m_Payload.m_StatusResponse.
3100                                                      m_le_bFlag2);
3101                                 Ret =
3102                                     EplDllkCalAsyncSetPendingRequests(uiNodeId,
3103                                                                       ((tEplDllAsyncReqPriority) ((bFlag1 & EPL_FRAME_FLAG2_PR) >> EPL_FRAME_FLAG2_PR_SHIFT)), (bFlag1 & EPL_FRAME_FLAG2_RS));
3104                         }
3105 #endif
3106
3107                         if (uiAsndServiceId < EPL_DLL_MAX_ASND_SERVICE_ID) {    // ASnd service ID is valid
3108                                 if (EplDllkInstance_g.m_aAsndFilter[uiAsndServiceId] == kEplDllAsndFilterAny) { // ASnd service ID is registered
3109                                         // forward frame via async receive FIFO to userspace
3110                                         Ret =
3111                                             EplDllkCalAsyncFrameReceived
3112                                             (&FrameInfo);
3113                                 } else if (EplDllkInstance_g.m_aAsndFilter[uiAsndServiceId] == kEplDllAsndFilterLocal) {        // ASnd service ID is registered, but only local node ID or broadcasts
3114                                         // shall be forwarded
3115                                         uiNodeId =
3116                                             AmiGetByteFromLe(&pFrame->
3117                                                              m_le_bDstNodeId);
3118                                         if ((uiNodeId ==
3119                                              EplDllkInstance_g.m_DllConfigParam.
3120                                              m_uiNodeId)
3121                                             || (uiNodeId == EPL_C_ADR_BROADCAST)) {     // ASnd frame is intended for us
3122                                                 // forward frame via async receive FIFO to userspace
3123                                                 Ret =
3124                                                     EplDllkCalAsyncFrameReceived
3125                                                     (&FrameInfo);
3126                                         }
3127                                 }
3128                         }
3129                         break;
3130                 }
3131
3132         default:
3133                 {
3134                         break;
3135                 }
3136         }
3137
3138         if (NmtEvent != kEplNmtEventNoEvent) {  // event for DLL and NMT state machine generated
3139                 Ret = EplDllkChangeState(NmtEvent, NmtState);
3140                 if (Ret != kEplSuccessful) {
3141                         goto Exit;
3142                 }
3143
3144                 if ((NmtEvent != kEplNmtEventDllCeAsnd)
3145                     && ((NmtState <= kEplNmtCsPreOperational1) || (NmtEvent != kEplNmtEventDllCePres))) {       // NMT state machine is not interested in ASnd frames and PRes frames when not CsNotActive or CsPreOp1
3146                         // inform NMT module
3147                         Event.m_EventSink = kEplEventSinkNmtk;
3148                         Event.m_EventType = kEplEventTypeNmtEvent;
3149                         Event.m_uiSize = sizeof(NmtEvent);
3150                         Event.m_pArg = &NmtEvent;
3151                         Ret = EplEventkPost(&Event);
3152                 }
3153         }
3154
3155       Exit:
3156         if (Ret != kEplSuccessful) {
3157                 u32 dwArg;
3158
3159                 BENCHMARK_MOD_02_TOGGLE(9);
3160
3161                 dwArg = EplDllkInstance_g.m_DllState | (NmtEvent << 8);
3162
3163                 // Error event for API layer
3164                 Ret = EplEventkPostError(kEplEventSourceDllk,
3165                                          Ret, sizeof(dwArg), &dwArg);
3166         }
3167         BENCHMARK_MOD_02_RESET(3);
3168         return;
3169 }
3170
3171 //---------------------------------------------------------------------------
3172 //
3173 // Function:    EplDllkCbFrameTransmitted()
3174 //
3175 // Description: called from EdrvInterruptHandler().
3176 //              It signals
3177 //
3178 // Parameters:  pRxBuffer_p             = receive buffer structure
3179 //
3180 // Returns:     (none)
3181 //
3182 //
3183 // State:
3184 //
3185 //---------------------------------------------------------------------------
3186
3187 static void EplDllkCbFrameTransmitted(tEdrvTxBuffer * pTxBuffer_p)
3188 {
3189         tEplKernel Ret = kEplSuccessful;
3190         tEplEvent Event;
3191         tEplDllAsyncReqPriority Priority;
3192         tEplNmtState NmtState;
3193
3194 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0) \
3195     && (EPL_DLL_PRES_READY_AFTER_SOC == FALSE)
3196         tEplFrameInfo FrameInfo;
3197 #endif
3198
3199         NmtState = EplNmtkGetNmtState();
3200
3201         if (NmtState <= kEplNmtGsResetConfiguration) {
3202                 goto Exit;
3203         }
3204
3205         if ((pTxBuffer_p - EplDllkInstance_g.m_pTxBuffer) == EPL_DLLK_TXFRAME_NMTREQ) { // frame from NMT request FIFO sent
3206                 // mark Tx-buffer as empty
3207                 pTxBuffer_p->m_uiTxMsgLen = EPL_DLLK_BUFLEN_EMPTY;
3208
3209                 // post event to DLL
3210                 Priority = kEplDllAsyncReqPrioNmt;
3211                 Event.m_EventSink = kEplEventSinkDllk;
3212                 Event.m_EventType = kEplEventTypeDllkFillTx;
3213                 EPL_MEMSET(&Event.m_NetTime, 0x00, sizeof(Event.m_NetTime));
3214                 Event.m_pArg = &Priority;
3215                 Event.m_uiSize = sizeof(Priority);
3216                 Ret = EplEventkPost(&Event);
3217         } else if ((pTxBuffer_p - EplDllkInstance_g.m_pTxBuffer) == EPL_DLLK_TXFRAME_NONEPL) {  // frame from generic priority FIFO sent
3218                 // mark Tx-buffer as empty
3219                 pTxBuffer_p->m_uiTxMsgLen = EPL_DLLK_BUFLEN_EMPTY;
3220
3221                 // post event to DLL
3222                 Priority = kEplDllAsyncReqPrioGeneric;
3223                 Event.m_EventSink = kEplEventSinkDllk;
3224                 Event.m_EventType = kEplEventTypeDllkFillTx;
3225                 EPL_MEMSET(&Event.m_NetTime, 0x00, sizeof(Event.m_NetTime));
3226                 Event.m_pArg = &Priority;
3227                 Event.m_uiSize = sizeof(Priority);
3228                 Ret = EplEventkPost(&Event);
3229         }
3230 #if ((((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0) \
3231     && (EPL_DLL_PRES_READY_AFTER_SOC == FALSE)) \
3232     || (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
3233         else if ((pTxBuffer_p->m_EplMsgType == kEplMsgTypePreq)
3234                  || (pTxBuffer_p->m_EplMsgType == kEplMsgTypePres)) {   // PRes resp. PReq frame sent
3235
3236 #if ((((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0) \
3237             && (EPL_DLL_PRES_READY_AFTER_SOC == FALSE))
3238                 {
3239                         // inform PDO module
3240                         FrameInfo.m_pFrame =
3241                             (tEplFrame *) pTxBuffer_p->m_pbBuffer;
3242                         FrameInfo.m_uiFrameSize = pTxBuffer_p->m_uiMaxBufferLen;
3243                         Ret = EplPdokCbPdoTransmitted(&FrameInfo);
3244                 }
3245 #endif
3246
3247 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
3248                 {
3249                         // if own Pres on MN, trigger SoA
3250                         if ((NmtState >= kEplNmtMsPreOperational2)
3251                             && (pTxBuffer_p ==
3252                                 &EplDllkInstance_g.
3253                                 m_pTxBuffer[EPL_DLLK_TXFRAME_PRES])) {
3254                                 Ret =
3255                                     EplDllkChangeState(kEplNmtEventDllMeSoaTrig,
3256                                                        NmtState);
3257                         }
3258                 }
3259 #endif
3260
3261 #if EPL_DLL_PRES_READY_AFTER_SOA != FALSE
3262                 goto Exit;
3263 #endif
3264         }
3265 #endif
3266 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
3267         else if (pTxBuffer_p->m_EplMsgType == kEplMsgTypeSoa) { // SoA frame sent
3268                 tEplNmtEvent NmtEvent = kEplNmtEventDllMeSoaSent;
3269
3270                 // check if we are invited
3271                 if (EplDllkInstance_g.m_uiLastTargetNodeId ==
3272                     EplDllkInstance_g.m_DllConfigParam.m_uiNodeId) {
3273                         tEplFrame *pTxFrame;
3274
3275                         if (EplDllkInstance_g.m_LastReqServiceId == kEplDllReqServiceStatus) {  // StatusRequest
3276                                 if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_STATUSRES].m_pbBuffer != NULL) {     // StatusRes does exist
3277
3278                                         pTxFrame =
3279                                             (tEplFrame *) EplDllkInstance_g.
3280                                             m_pTxBuffer
3281                                             [EPL_DLLK_TXFRAME_STATUSRES].
3282                                             m_pbBuffer;
3283                                         // update StatusRes frame (NMT state, EN, EC, RS, PR flags)
3284                                         AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.
3285                                                        m_Payload.
3286                                                        m_StatusResponse.
3287                                                        m_le_bNmtStatus,
3288                                                        (u8) NmtState);
3289                                         AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.
3290                                                        m_Payload.
3291                                                        m_StatusResponse.
3292                                                        m_le_bFlag1,
3293                                                        EplDllkInstance_g.
3294                                                        m_bFlag1);
3295                                         AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.
3296                                                        m_Payload.
3297                                                        m_StatusResponse.
3298                                                        m_le_bFlag2,
3299                                                        EplDllkInstance_g.
3300                                                        m_bFlag2);
3301                                         // send StatusRes
3302                                         Ret =
3303                                             EdrvSendTxMsg(&EplDllkInstance_g.
3304                                                           m_pTxBuffer
3305                                                           [EPL_DLLK_TXFRAME_STATUSRES]);
3306                                         if (Ret != kEplSuccessful) {
3307                                                 goto Exit;
3308                                         }
3309                                         TGT_DBG_SIGNAL_TRACE_POINT(8);
3310
3311                                 }
3312                         } else if (EplDllkInstance_g.m_LastReqServiceId == kEplDllReqServiceIdent) {    // IdentRequest
3313                                 if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_IDENTRES].m_pbBuffer != NULL) {      // IdentRes does exist
3314                                         pTxFrame =
3315                                             (tEplFrame *) EplDllkInstance_g.
3316                                             m_pTxBuffer
3317                                             [EPL_DLLK_TXFRAME_IDENTRES].
3318                                             m_pbBuffer;
3319                                         // update IdentRes frame (NMT state, RS, PR flags)
3320                                         AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.
3321                                                        m_Payload.
3322                                                        m_IdentResponse.
3323                                                        m_le_bNmtStatus,
3324                                                        (u8) NmtState);
3325                                         AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.
3326                                                        m_Payload.
3327                                                        m_IdentResponse.
3328                                                        m_le_bFlag2,
3329                                                        EplDllkInstance_g.
3330                                                        m_bFlag2);
3331                                         // send IdentRes
3332                                         Ret =
3333                                             EdrvSendTxMsg(&EplDllkInstance_g.
3334                                                           m_pTxBuffer
3335                                                           [EPL_DLLK_TXFRAME_IDENTRES]);
3336                                         if (Ret != kEplSuccessful) {
3337                                                 goto Exit;
3338                                         }
3339                                         TGT_DBG_SIGNAL_TRACE_POINT(7);
3340                                 }
3341                         } else if (EplDllkInstance_g.m_LastReqServiceId == kEplDllReqServiceNmtRequest) {       // NmtRequest
3342                                 if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_pbBuffer != NULL) {        // NmtRequest does exist
3343                                         // check if frame is not empty and not being filled
3344                                         if (EplDllkInstance_g.
3345                                             m_pTxBuffer
3346                                             [EPL_DLLK_TXFRAME_NMTREQ].
3347                                             m_uiTxMsgLen >
3348                                             EPL_DLLK_BUFLEN_FILLING) {
3349                                                 // check if this frame is a NMT command,
3350                                                 // then forward this frame back to NmtMnu module,
3351                                                 // because it needs the time, when this frame is
3352                                                 // actually sent, to start the timer for monitoring
3353                                                 // the NMT state change.
3354
3355                                                 pTxFrame =
3356                                                     (tEplFrame *)
3357                                                     EplDllkInstance_g.
3358                                                     m_pTxBuffer
3359                                                     [EPL_DLLK_TXFRAME_NMTREQ].
3360                                                     m_pbBuffer;
3361                                                 if ((AmiGetByteFromLe
3362                                                      (&pTxFrame->
3363                                                       m_le_bMessageType)
3364                                                      == (u8) kEplMsgTypeAsnd)
3365                                                     &&
3366                                                     (AmiGetByteFromLe
3367                                                      (&pTxFrame->m_Data.m_Asnd.
3368                                                       m_le_bServiceId)
3369                                                      == (u8) kEplDllAsndNmtCommand)) {  // post event directly to NmtMnu module
3370                                                         Event.m_EventSink =
3371                                                             kEplEventSinkNmtMnu;
3372                                                         Event.m_EventType =
3373                                                             kEplEventTypeNmtMnuNmtCmdSent;
3374                                                         Event.m_uiSize =
3375                                                             EplDllkInstance_g.
3376                                                             m_pTxBuffer
3377                                                             [EPL_DLLK_TXFRAME_NMTREQ].
3378                                                             m_uiTxMsgLen;
3379                                                         Event.m_pArg = pTxFrame;
3380                                                         Ret =
3381                                                             EplEventkPost
3382                                                             (&Event);
3383
3384                                                 }
3385                                                 // send NmtRequest
3386                                                 Ret =
3387                                                     EdrvSendTxMsg
3388                                                     (&EplDllkInstance_g.
3389                                                      m_pTxBuffer
3390                                                      [EPL_DLLK_TXFRAME_NMTREQ]);
3391                                                 if (Ret != kEplSuccessful) {
3392                                                         goto Exit;
3393                                                 }
3394
3395                                         }
3396                                 }
3397
3398                         } else if (EplDllkInstance_g.m_LastReqServiceId == kEplDllReqServiceUnspecified) {      // unspecified invite
3399                                 if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NONEPL].m_pbBuffer != NULL) {        // non-EPL frame does exist
3400                                         // check if frame is not empty and not being filled
3401                                         if (EplDllkInstance_g.
3402                                             m_pTxBuffer
3403                                             [EPL_DLLK_TXFRAME_NONEPL].
3404                                             m_uiTxMsgLen >
3405                                             EPL_DLLK_BUFLEN_FILLING) {
3406                                                 // send non-EPL frame
3407                                                 Ret =
3408                                                     EdrvSendTxMsg
3409                                                     (&EplDllkInstance_g.
3410                                                      m_pTxBuffer
3411                                                      [EPL_DLLK_TXFRAME_NONEPL]);
3412                                                 if (Ret != kEplSuccessful) {
3413                                                         goto Exit;
3414                                                 }
3415
3416                                         }
3417                                 }
3418                         }
3419                         // ASnd frame was sent, remove the request
3420                         EplDllkInstance_g.m_LastReqServiceId =
3421                             kEplDllReqServiceNo;
3422                 }
3423                 // forward event to ErrorHandler and PDO module
3424                 Event.m_EventSink = kEplEventSinkNmtk;
3425                 Event.m_EventType = kEplEventTypeNmtEvent;
3426                 Event.m_uiSize = sizeof(NmtEvent);
3427                 Event.m_pArg = &NmtEvent;
3428                 Ret = EplEventkPost(&Event);
3429                 if (Ret != kEplSuccessful) {
3430                         goto Exit;
3431                 }
3432         }
3433 #endif
3434
3435 #if EPL_DLL_PRES_READY_AFTER_SOA != FALSE
3436         else {                  // d.k.: Why that else? on CN it is entered on IdentRes and StatusRes
3437                 goto Exit;
3438         }
3439
3440         // signal process function readiness of PRes frame
3441         Event.m_EventSink = kEplEventSinkDllk;
3442         Event.m_EventType = kEplEventTypeDllkPresReady;
3443         Event.m_uiSize = 0;
3444         Event.m_pArg = NULL;
3445         Ret = EplEventkPost(&Event);
3446
3447 #endif
3448
3449       Exit:
3450         if (Ret != kEplSuccessful) {
3451                 u32 dwArg;
3452
3453                 BENCHMARK_MOD_02_TOGGLE(9);
3454
3455                 dwArg =
3456                     EplDllkInstance_g.m_DllState | (pTxBuffer_p->
3457                                                     m_EplMsgType << 16);
3458
3459                 // Error event for API layer
3460                 Ret = EplEventkPostError(kEplEventSourceDllk,
3461                                          Ret, sizeof(dwArg), &dwArg);
3462         }
3463
3464         return;
3465 }
3466
3467 //---------------------------------------------------------------------------
3468 //
3469 // Function:    EplDllkCheckFrame()
3470 //
3471 // Description: check frame and set missing information
3472 //
3473 // Parameters:  pFrame_p                = ethernet frame
3474 //              uiFrameSize_p           = size of frame
3475 //
3476 // Returns:     tEplKernel              = error code
3477 //
3478 //
3479 // State:
3480 //
3481 //---------------------------------------------------------------------------
3482
3483 static tEplKernel EplDllkCheckFrame(tEplFrame * pFrame_p,
3484                                     unsigned int uiFrameSize_p)
3485 {
3486         tEplMsgType MsgType;
3487         u16 wEtherType;
3488
3489         // check frame
3490         if (pFrame_p != NULL) {
3491                 // check SrcMAC
3492                 if (AmiGetQword48FromBe(pFrame_p->m_be_abSrcMac) == 0) {
3493                         // source MAC address
3494                         EPL_MEMCPY(&pFrame_p->m_be_abSrcMac[0],
3495                                    &EplDllkInstance_g.m_be_abSrcMac[0], 6);
3496                 }
3497                 // check ethertype
3498                 wEtherType = AmiGetWordFromBe(&pFrame_p->m_be_wEtherType);
3499                 if (wEtherType == 0) {
3500                         // assume EPL frame
3501                         wEtherType = EPL_C_DLL_ETHERTYPE_EPL;
3502                         AmiSetWordToBe(&pFrame_p->m_be_wEtherType, wEtherType);
3503                 }
3504
3505                 if (wEtherType == EPL_C_DLL_ETHERTYPE_EPL) {
3506                         // source node ID
3507                         AmiSetByteToLe(&pFrame_p->m_le_bSrcNodeId,
3508                                        (u8) EplDllkInstance_g.
3509                                        m_DllConfigParam.m_uiNodeId);
3510
3511                         // check message type
3512                         MsgType =
3513                             AmiGetByteFromLe(&pFrame_p->m_le_bMessageType);
3514                         if (MsgType == 0) {
3515                                 MsgType = kEplMsgTypeAsnd;
3516                                 AmiSetByteToLe(&pFrame_p->m_le_bMessageType,
3517                                                (u8) MsgType);
3518                         }
3519
3520                         if (MsgType == kEplMsgTypeAsnd) {
3521                                 // destination MAC address
3522                                 AmiSetQword48ToBe(&pFrame_p->m_be_abDstMac[0],
3523                                                   EPL_C_DLL_MULTICAST_ASND);
3524                         }
3525
3526                 }
3527         }
3528
3529         return kEplSuccessful;
3530 }
3531
3532 //---------------------------------------------------------------------------
3533 //
3534 // Function:    EplDllkCbCnTimer()
3535 //
3536 // Description: called by timer module. It monitors the EPL cycle when it is a CN.
3537 //
3538 // Parameters:  pEventArg_p             = timer event argument
3539 //
3540 // Returns:     tEplKernel              = error code
3541 //
3542 //
3543 // State:
3544 //
3545 //---------------------------------------------------------------------------
3546
3547 #if EPL_TIMER_USE_HIGHRES != FALSE
3548 static tEplKernel EplDllkCbCnTimer(tEplTimerEventArg *pEventArg_p)
3549 {
3550         tEplKernel Ret = kEplSuccessful;
3551         tEplNmtState NmtState;
3552
3553 #if EPL_TIMER_USE_HIGHRES != FALSE
3554         if (pEventArg_p->m_TimerHdl != EplDllkInstance_g.m_TimerHdlCycle) {     // zombie callback
3555                 // just exit
3556                 goto Exit;
3557         }
3558 #endif
3559
3560         NmtState = EplNmtkGetNmtState();
3561
3562         if (NmtState <= kEplNmtGsResetConfiguration) {
3563                 goto Exit;
3564         }
3565
3566         Ret = EplDllkChangeState(kEplNmtEventDllCeFrameTimeout, NmtState);
3567         if (Ret != kEplSuccessful) {
3568                 goto Exit;
3569         }
3570         // 2008/10/15 d.k. reprogramming of timer not necessary,
3571         // because it will be programmed, when SoC is received.
3572 /*
3573     // reprogram timer
3574 #if EPL_TIMER_USE_HIGHRES != FALSE
3575     if ((NmtState > kEplNmtCsPreOperational1)
3576         && (EplDllkInstance_g.m_ullFrameTimeout != 0))
3577     {
3578         Ret = EplTimerHighReskModifyTimerNs(&EplDllkInstance_g.m_TimerHdlCycle, EplDllkInstance_g.m_ullFrameTimeout, EplDllkCbCnTimer, 0L, FALSE);
3579     }
3580 #endif
3581 */
3582
3583       Exit:
3584         if (Ret != kEplSuccessful) {
3585                 u32 dwArg;
3586
3587                 BENCHMARK_MOD_02_TOGGLE(9);
3588
3589                 dwArg =
3590                     EplDllkInstance_g.
3591                     m_DllState | (kEplNmtEventDllCeFrameTimeout << 8);
3592
3593                 // Error event for API layer
3594                 Ret = EplEventkPostError(kEplEventSourceDllk,
3595                                          Ret, sizeof(dwArg), &dwArg);
3596         }
3597
3598         return Ret;
3599 }
3600 #endif
3601
3602 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
3603
3604 //---------------------------------------------------------------------------
3605 //
3606 // Function:    EplDllkCbMnTimerCycle()
3607 //
3608 // Description: called by timer module. It triggers the SoC when it is a MN.
3609 //
3610 // Parameters:  pEventArg_p             = timer event argument
3611 //
3612 // Returns:     tEplKernel              = error code
3613 //
3614 //
3615 // State:
3616 //
3617 //---------------------------------------------------------------------------
3618
3619 static tEplKernel EplDllkCbMnTimerCycle(tEplTimerEventArg *pEventArg_p)
3620 {
3621         tEplKernel Ret = kEplSuccessful;
3622         tEplNmtState NmtState;
3623
3624 #if EPL_TIMER_USE_HIGHRES != FALSE
3625         if (pEventArg_p->m_TimerHdl != EplDllkInstance_g.m_TimerHdlCycle) {     // zombie callback
3626                 // just exit
3627                 goto Exit;
3628         }
3629 #endif
3630
3631         NmtState = EplNmtkGetNmtState();
3632
3633         if (NmtState <= kEplNmtGsResetConfiguration) {
3634                 goto Exit;
3635         }
3636
3637         Ret = EplDllkChangeState(kEplNmtEventDllMeSocTrig, NmtState);
3638
3639       Exit:
3640         if (Ret != kEplSuccessful) {
3641                 u32 dwArg;
3642
3643                 BENCHMARK_MOD_02_TOGGLE(9);
3644
3645                 dwArg =
3646                     EplDllkInstance_g.
3647                     m_DllState | (kEplNmtEventDllMeSocTrig << 8);
3648
3649                 // Error event for API layer
3650                 Ret = EplEventkPostError(kEplEventSourceDllk,
3651                                          Ret, sizeof(dwArg), &dwArg);
3652         }
3653
3654         return Ret;
3655 }
3656
3657 //---------------------------------------------------------------------------
3658 //
3659 // Function:    EplDllkCbMnTimerResponse()
3660 //
3661 // Description: called by timer module. It monitors the PRes timeout.
3662 //
3663 // Parameters:  pEventArg_p             = timer event argument
3664 //
3665 // Returns:     tEplKernel              = error code
3666 //
3667 //
3668 // State:
3669 //
3670 //---------------------------------------------------------------------------
3671
3672 static tEplKernel EplDllkCbMnTimerResponse(tEplTimerEventArg *pEventArg_p)
3673 {
3674         tEplKernel Ret = kEplSuccessful;
3675         tEplNmtState NmtState;
3676
3677 #if EPL_TIMER_USE_HIGHRES != FALSE
3678         if (pEventArg_p->m_TimerHdl != EplDllkInstance_g.m_TimerHdlResponse) {  // zombie callback
3679                 // just exit
3680                 goto Exit;
3681         }
3682 #endif
3683
3684         NmtState = EplNmtkGetNmtState();
3685
3686         if (NmtState <= kEplNmtGsResetConfiguration) {
3687                 goto Exit;
3688         }
3689
3690         Ret = EplDllkChangeState(kEplNmtEventDllMePresTimeout, NmtState);
3691
3692       Exit:
3693         if (Ret != kEplSuccessful) {
3694                 u32 dwArg;
3695
3696                 BENCHMARK_MOD_02_TOGGLE(9);
3697
3698                 dwArg =
3699                     EplDllkInstance_g.
3700                     m_DllState | (kEplNmtEventDllMePresTimeout << 8);
3701
3702                 // Error event for API layer
3703                 Ret = EplEventkPostError(kEplEventSourceDllk,
3704                                          Ret, sizeof(dwArg), &dwArg);
3705         }
3706
3707         return Ret;
3708 }
3709
3710 //---------------------------------------------------------------------------
3711 //
3712 // Function:    EplDllkGetNodeInfo()
3713 //
3714 // Description: returns node info structure of the specified node.
3715 //
3716 // Parameters:  uiNodeId_p              = node ID
3717 //
3718 // Returns:     tEplDllkNodeInfo*       = pointer to internal node info structure
3719 //
3720 //
3721 // State:
3722 //
3723 //---------------------------------------------------------------------------
3724
3725 static tEplDllkNodeInfo *EplDllkGetNodeInfo(unsigned int uiNodeId_p)
3726 {
3727         // $$$ d.k.: use hash algorithm to retrieve the appropriate node info structure
3728         //           if size of array is less than 254.
3729         uiNodeId_p--;           // node ID starts at 1 but array at 0
3730         if (uiNodeId_p >= tabentries(EplDllkInstance_g.m_aNodeInfo)) {
3731                 return NULL;
3732         } else {
3733                 return &EplDllkInstance_g.m_aNodeInfo[uiNodeId_p];
3734         }
3735 }
3736
3737 //---------------------------------------------------------------------------
3738 //
3739 // Function:    EplDllkMnSendSoa()
3740 //
3741 // Description: it updates and transmits the SoA.
3742 //
3743 // Parameters:  NmtState_p              = current NMT state
3744 //              pDllStateProposed_p     = proposed DLL state
3745 //              fEnableInvitation_p     = enable invitation for asynchronous phase
3746 //                                        it will be disabled for EPL_C_DLL_PREOP1_START_CYCLES SoAs
3747 //
3748 // Returns:     tEplKernel              = error code
3749 //
3750 //
3751 // State:
3752 //
3753 //---------------------------------------------------------------------------
3754
3755 static tEplKernel EplDllkMnSendSoa(tEplNmtState NmtState_p,
3756                                    tEplDllState * pDllStateProposed_p,
3757                                    BOOL fEnableInvitation_p)
3758 {
3759         tEplKernel Ret = kEplSuccessful;
3760         tEdrvTxBuffer *pTxBuffer = NULL;
3761         tEplFrame *pTxFrame;
3762         tEplDllkNodeInfo *pNodeInfo;
3763
3764         *pDllStateProposed_p = kEplDllMsNonCyclic;
3765
3766         pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_SOA];
3767         if (pTxBuffer->m_pbBuffer != NULL) {    // SoA does exist
3768                 pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
3769
3770                 if (fEnableInvitation_p != FALSE) {     // fetch target of asynchronous phase
3771                         if (EplDllkInstance_g.m_bFlag2 == 0) {  // own queues are empty
3772                                 EplDllkInstance_g.m_LastReqServiceId =
3773                                     kEplDllReqServiceNo;
3774                         } else if (((tEplDllAsyncReqPriority) (EplDllkInstance_g.m_bFlag2 >> EPL_FRAME_FLAG2_PR_SHIFT)) == kEplDllAsyncReqPrioNmt) {    // frames in own NMT request queue available
3775                                 EplDllkInstance_g.m_LastReqServiceId =
3776                                     kEplDllReqServiceNmtRequest;
3777                         } else {
3778                                 EplDllkInstance_g.m_LastReqServiceId =
3779                                     kEplDllReqServiceUnspecified;
3780                         }
3781                         Ret =
3782                             EplDllkCalAsyncGetSoaRequest(&EplDllkInstance_g.
3783                                                          m_LastReqServiceId,
3784                                                          &EplDllkInstance_g.
3785                                                          m_uiLastTargetNodeId);
3786                         if (Ret != kEplSuccessful) {
3787                                 goto Exit;
3788                         }
3789                         if (EplDllkInstance_g.m_LastReqServiceId != kEplDllReqServiceNo) {      // asynchronous phase will be assigned to one node
3790                                 if (EplDllkInstance_g.m_uiLastTargetNodeId == EPL_C_ADR_INVALID) {      // exchange invalid node ID with local node ID
3791                                         EplDllkInstance_g.m_uiLastTargetNodeId =
3792                                             EplDllkInstance_g.m_DllConfigParam.
3793                                             m_uiNodeId;
3794                                         // d.k. DLL state WaitAsndTrig is not helpful;
3795                                         //      so just step over to WaitSocTrig,
3796                                         //      because own ASnd is sent automatically in CbFrameTransmitted() after SoA.
3797                                         //*pDllStateProposed_p = kEplDllMsWaitAsndTrig;
3798                                         *pDllStateProposed_p =
3799                                             kEplDllMsWaitSocTrig;
3800                                 } else {        // assignment to CN
3801                                         *pDllStateProposed_p =
3802                                             kEplDllMsWaitAsnd;
3803                                 }
3804
3805                                 pNodeInfo =
3806                                     EplDllkGetNodeInfo(EplDllkInstance_g.
3807                                                        m_uiLastTargetNodeId);
3808                                 if (pNodeInfo == NULL) {        // no node info structure available
3809                                         Ret = kEplDllNoNodeInfo;
3810                                         goto Exit;
3811                                 }
3812                                 // update frame (EA, ER flags)
3813                                 AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.
3814                                                m_le_bFlag1,
3815                                                pNodeInfo->
3816                                                m_bSoaFlag1 & (EPL_FRAME_FLAG1_EA
3817                                                               |
3818                                                               EPL_FRAME_FLAG1_ER));
3819                         } else {        // no assignment of asynchronous phase
3820                                 *pDllStateProposed_p = kEplDllMsWaitSocTrig;
3821                                 EplDllkInstance_g.m_uiLastTargetNodeId =
3822                                     EPL_C_ADR_INVALID;
3823                         }
3824
3825                         // update frame (target)
3826                         AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.
3827                                        m_le_bReqServiceId,
3828                                        (u8) EplDllkInstance_g.
3829                                        m_LastReqServiceId);
3830                         AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.
3831                                        m_le_bReqServiceTarget,
3832                                        (u8) EplDllkInstance_g.
3833                                        m_uiLastTargetNodeId);
3834
3835                 } else {        // invite nobody
3836                         // update frame (target)
3837                         AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.
3838                                        m_le_bReqServiceId, (u8) 0);
3839                         AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.
3840                                        m_le_bReqServiceTarget, (u8) 0);
3841                 }
3842
3843                 // update frame (NMT state)
3844                 AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.m_le_bNmtStatus,
3845                                (u8) NmtState_p);
3846
3847                 // send SoA frame
3848                 Ret = EdrvSendTxMsg(pTxBuffer);
3849         }
3850
3851       Exit:
3852         return Ret;
3853 }
3854
3855 //---------------------------------------------------------------------------
3856 //
3857 // Function:    EplDllkMnSendSoc()
3858 //
3859 // Description: it updates and transmits the SoA.
3860 //
3861 // Parameters:  (none)
3862 //
3863 // Returns:     tEplKernel              = error code
3864 //
3865 //
3866 // State:
3867 //
3868 //---------------------------------------------------------------------------
3869
3870 static tEplKernel EplDllkMnSendSoc(void)
3871 {
3872         tEplKernel Ret = kEplSuccessful;
3873         tEdrvTxBuffer *pTxBuffer = NULL;
3874         tEplFrame *pTxFrame;
3875         tEplEvent Event;
3876
3877         pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_SOC];
3878         if (pTxBuffer->m_pbBuffer != NULL) {    // SoC does exist
3879                 pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
3880
3881                 // $$$ update NetTime
3882
3883                 // send SoC frame
3884                 Ret = EdrvSendTxMsg(pTxBuffer);
3885                 if (Ret != kEplSuccessful) {
3886                         goto Exit;
3887                 }
3888                 // trigger synchronous task
3889                 Event.m_EventSink = kEplEventSinkSync;
3890                 Event.m_EventType = kEplEventTypeSync;
3891                 Event.m_uiSize = 0;
3892                 Ret = EplEventkPost(&Event);
3893         }
3894
3895       Exit:
3896         return Ret;
3897 }
3898
3899 //---------------------------------------------------------------------------
3900 //
3901 // Function:    EplDllkMnSendPreq()
3902 //
3903 // Description: it updates and transmits the PReq for the next isochronous CN
3904 //              or own PRes if enabled.
3905 //
3906 // Parameters:  NmtState_p              = current NMT state
3907 //              pDllStateProposed_p     = proposed DLL state
3908 //
3909 // Returns:     tEplKernel              = error code
3910 //
3911 //
3912 // State:
3913 //
3914 //---------------------------------------------------------------------------
3915
3916 static tEplKernel EplDllkMnSendPreq(tEplNmtState NmtState_p,
3917                                     tEplDllState * pDllStateProposed_p)
3918 {
3919         tEplKernel Ret = kEplSuccessful;
3920         tEdrvTxBuffer *pTxBuffer = NULL;
3921         tEplFrame *pTxFrame;
3922         u8 bFlag1 = 0;
3923
3924         if (EplDllkInstance_g.m_pCurNodeInfo == NULL) { // start with first isochronous CN
3925                 EplDllkInstance_g.m_pCurNodeInfo =
3926                     EplDllkInstance_g.m_pFirstNodeInfo;
3927         } else {                // iterate to next isochronous CN
3928                 EplDllkInstance_g.m_pCurNodeInfo =
3929                     EplDllkInstance_g.m_pCurNodeInfo->m_pNextNodeInfo;
3930         }
3931
3932         if (EplDllkInstance_g.m_pCurNodeInfo == NULL) { // last isochronous CN reached
3933                 Ret = EplDllkMnSendSoa(NmtState_p, pDllStateProposed_p, TRUE);
3934                 goto Exit;
3935         } else {
3936                 pTxBuffer = EplDllkInstance_g.m_pCurNodeInfo->m_pPreqTxBuffer;
3937                 bFlag1 =
3938                     EplDllkInstance_g.m_pCurNodeInfo->
3939                     m_bSoaFlag1 & EPL_FRAME_FLAG1_EA;
3940                 *pDllStateProposed_p = kEplDllMsWaitPres;
3941
3942                 // start PRes Timer
3943                 // $$$ d.k.: maybe move this call to CbFrameTransmitted(), because the time should run from there
3944 #if EPL_TIMER_USE_HIGHRES != FALSE
3945                 Ret =
3946                     EplTimerHighReskModifyTimerNs(&EplDllkInstance_g.
3947                                                   m_TimerHdlResponse,
3948                                                   EplDllkInstance_g.
3949                                                   m_pCurNodeInfo->
3950                                                   m_dwPresTimeout,
3951                                                   EplDllkCbMnTimerResponse, 0L,
3952                                                   FALSE);
3953 #endif
3954         }
3955
3956         if (pTxBuffer == NULL) {        // PReq does not exist
3957                 Ret = kEplDllTxBufNotReady;
3958                 goto Exit;
3959         }
3960
3961         pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
3962
3963         if (pTxFrame != NULL) { // PReq does exist
3964                 if (NmtState_p == kEplNmtMsOperational) {       // leave RD flag untouched
3965                         bFlag1 |=
3966                             AmiGetByteFromLe(&pTxFrame->m_Data.m_Preq.
3967                                              m_le_bFlag1) & EPL_FRAME_FLAG1_RD;
3968                 }
3969
3970                 if (pTxBuffer == &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_PRES]) {       // PRes of MN will be sent
3971                         // update NMT state
3972                         AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bNmtStatus,
3973                                        (u8) NmtState_p);
3974                         *pDllStateProposed_p = kEplDllMsWaitSoaTrig;
3975                 }
3976                 // $$$ d.k. set EPL_FRAME_FLAG1_MS if necessary
3977                 // update frame (Flag1)
3978                 AmiSetByteToLe(&pTxFrame->m_Data.m_Preq.m_le_bFlag1, bFlag1);
3979
3980                 // calculate frame size from payload size
3981                 pTxBuffer->m_uiTxMsgLen =
3982                     AmiGetWordFromLe(&pTxFrame->m_Data.m_Preq.m_le_wSize) + 24;
3983
3984                 // send PReq frame
3985                 Ret = EdrvSendTxMsg(pTxBuffer);
3986         } else {
3987                 Ret = kEplDllTxFrameInvalid;
3988         }
3989
3990       Exit:
3991         return Ret;
3992 }
3993
3994 //---------------------------------------------------------------------------
3995 //
3996 // Function:    EplDllkAsyncFrameNotReceived()
3997 //
3998 // Description: passes empty ASnd frame to receive FIFO.
3999 //              It will be called only for frames with registered AsndServiceIds
4000 //              (only kEplDllAsndFilterAny).
4001 //
4002 // Parameters:  none
4003 //
4004 // Returns:     tEplKernel              = error code
4005 //
4006 //
4007 // State:
4008 //
4009 //---------------------------------------------------------------------------
4010
4011 static tEplKernel EplDllkAsyncFrameNotReceived(tEplDllReqServiceId
4012                                                ReqServiceId_p,
4013                                                unsigned int uiNodeId_p)
4014 {
4015         tEplKernel Ret = kEplSuccessful;
4016         u8 abBuffer[18];
4017         tEplFrame *pFrame = (tEplFrame *) abBuffer;
4018         tEplFrameInfo FrameInfo;
4019
4020         // check if previous SoA invitation was not answered
4021         switch (ReqServiceId_p) {
4022         case kEplDllReqServiceIdent:
4023         case kEplDllReqServiceStatus:
4024                 // ASnd service registered?
4025                 if (EplDllkInstance_g.m_aAsndFilter[ReqServiceId_p] == kEplDllAsndFilterAny) {  // ASnd service ID is registered
4026                         AmiSetByteToLe(&pFrame->m_le_bSrcNodeId,
4027                                        (u8) uiNodeId_p);
4028                         // EPL MsgType ASnd
4029                         AmiSetByteToLe(&pFrame->m_le_bMessageType,
4030                                        (u8) kEplMsgTypeAsnd);
4031                         // ASnd Service ID
4032                         AmiSetByteToLe(&pFrame->m_Data.m_Asnd.m_le_bServiceId,
4033                                        (u8) ReqServiceId_p);
4034                         // create frame info structure
4035                         FrameInfo.m_pFrame = pFrame;
4036                         FrameInfo.m_uiFrameSize = 18;   // empty non existing ASnd frame
4037                         // forward frame via async receive FIFO to userspace
4038                         Ret = EplDllkCalAsyncFrameReceived(&FrameInfo);
4039                 }
4040                 break;
4041         default:
4042                 // no invitation issued or it was successfully answered or it is uninteresting
4043                 break;
4044         }
4045
4046         return Ret;
4047 }
4048
4049 #endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
4050
4051 #endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
4052 // EOF