drivers/staging/epl/EplApiGeneric.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 generic EPL API 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: EplApiGeneric.c,v $
  53
  54                 $Author: D.Krueger $
  55
  56                 $Revision: 1.21 $  $Date: 2008/11/21 09:00:38 $
  57
  58                 $State: Exp $
  59
  60                 Build Environment:
  61                     GCC V3.4
  62
  63   -------------------------------------------------------------------------
  64
  65   Revision History:
  66
  67   2006/09/05 d.k.:   start of the implementation, version 1.00
  68
  69 ****************************************************************************/
  70
  71 #include "Epl.h"
  72 #include "kernel/EplDllk.h"
  73 #include "kernel/EplErrorHandlerk.h"
  74 #include "kernel/EplEventk.h"
  75 #include "kernel/EplNmtk.h"
  76 #include "kernel/EplObdk.h"
  77 #include "kernel/EplTimerk.h"
  78 #include "kernel/EplDllkCal.h"
  79 #include "kernel/EplPdokCal.h"
  80 #include "user/EplDlluCal.h"
  81 #include "user/EplLedu.h"
  82 #include "user/EplNmtCnu.h"
  83 #include "user/EplNmtMnu.h"
  84 #include "user/EplSdoComu.h"
  85 #include "user/EplIdentu.h"
  86 #include "user/EplStatusu.h"
  87
  88 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
  89 #include "kernel/EplPdok.h"
  90 #endif
  91
  92 #include "SharedBuff.h"
  93
  94 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) == 0)
  95 #error "EPL API layer needs EPL module OBDK!"
  96 #endif
  97
  98 /***************************************************************************/
  99 /*                                                                         */
 100 /*                                                                         */
 101 /*          G L O B A L   D E F I N I T I O N S                            */
 102 /*                                                                         */
 103 /*                                                                         */
 104 /***************************************************************************/
 105
 106 //---------------------------------------------------------------------------
 107 // const defines
 108 //---------------------------------------------------------------------------
 109
 110 //---------------------------------------------------------------------------
 111 // local types
 112 //---------------------------------------------------------------------------
 113
 114 //---------------------------------------------------------------------------
 115 // modul globale vars
 116 //---------------------------------------------------------------------------
 117
 118 //---------------------------------------------------------------------------
 119 // local function prototypes
 120 //---------------------------------------------------------------------------
 121
 122 /***************************************************************************/
 123 /*                                                                         */
 124 /*                                                                         */
 125 /*          C L A S S  EplApi                                              */
 126 /*                                                                         */
 127 /*                                                                         */
 128 /***************************************************************************/
 129 //
 130 // Description:
 131 //
 132 //
 133 /***************************************************************************/
 134
 135 //=========================================================================//
 136 //                                                                         //
 137 //          P R I V A T E   D E F I N I T I O N S                          //
 138 //                                                                         //
 139 //=========================================================================//
 140
 141 //---------------------------------------------------------------------------
 142 // const defines
 143 //---------------------------------------------------------------------------
 144
 145 //---------------------------------------------------------------------------
 146 // local types
 147 //---------------------------------------------------------------------------
 148
 149 typedef struct {
 150         tEplApiInitParam m_InitParam;
 151
 152 } tEplApiInstance;
 153
 154 //---------------------------------------------------------------------------
 155 // local vars
 156 //---------------------------------------------------------------------------
 157
 158 static tEplApiInstance EplApiInstance_g;
 159
 160 //---------------------------------------------------------------------------
 161 // local function prototypes
 162 //---------------------------------------------------------------------------
 163
 164 // NMT state change event callback function
 165 static tEplKernel PUBLIC EplApiCbNmtStateChange(tEplEventNmtStateChange
 166                                                 NmtStateChange_p);
 167
 168 // update DLL configuration from OD
 169 static tEplKernel PUBLIC EplApiUpdateDllConfig(BOOL fUpdateIdentity_p);
 170
 171 // update OD from init param
 172 static tEplKernel PUBLIC EplApiUpdateObd(void);
 173
 174 // process events from user event queue
 175 static tEplKernel PUBLIC EplApiProcessEvent(tEplEvent * pEplEvent_p);
 176
 177 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
 178 // callback function of SDO module
 179 static tEplKernel PUBLIC EplApiCbSdoCon(tEplSdoComFinished * pSdoComFinished_p);
 180 #endif
 181
 182 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
 183 // callback functions of NmtMnu module
 184 static tEplKernel PUBLIC EplApiCbNodeEvent(unsigned int uiNodeId_p,
 185                                            tEplNmtNodeEvent NodeEvent_p,
 186                                            tEplNmtState NmtState_p,
 187                                            WORD wErrorCode_p,
 188                                            BOOL fMandatory_p);
 189
 190 static tEplKernel PUBLIC EplApiCbBootEvent(tEplNmtBootEvent BootEvent_p,
 191                                            tEplNmtState NmtState_p,
 192                                            WORD wErrorCode_p);
 193 #endif
 194
 195 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0)
 196 // callback function of Ledu module
 197 static tEplKernel PUBLIC EplApiCbLedStateChange(tEplLedType LedType_p,
 198                                                 BOOL fOn_p);
 199 #endif
 200
 201 // OD initialization function (implemented in Objdict.c)
 202 tEplKernel PUBLIC EplObdInitRam(tEplObdInitParam MEM * pInitParam_p);
 203
 204 //=========================================================================//
 205 //                                                                         //
 206 //          P U B L I C   F U N C T I O N S                                //
 207 //                                                                         //
 208 //=========================================================================//
 209
 210 //---------------------------------------------------------------------------
 211 //
 212 // Function:    EplApiInitialize()
 213 //
 214 // Description: add and initialize new instance of EPL stack.
 215 //              After return from this function the application must start
 216 //              the NMT state machine via
 217 //              EplApiExecNmtCommand(kEplNmtEventSwReset)
 218 //              and thereby the whole EPL stack :-)
 219 //
 220 // Parameters:  pInitParam_p            = initialisation parameters
 221 //
 222 // Returns:     tEplKernel              = error code
 223 //
 224 //
 225 // State:
 226 //
 227 //---------------------------------------------------------------------------
 228
 229 tEplKernel PUBLIC EplApiInitialize(tEplApiInitParam * pInitParam_p)
 230 {
 231         tEplKernel Ret = kEplSuccessful;
 232         tEplObdInitParam ObdInitParam;
 233         tEplDllkInitParam DllkInitParam;
 234 #ifndef EPL_NO_FIFO
 235         tShbError ShbError;
 236 #endif
 237
 238         // reset instance structure
 239         EPL_MEMSET(&EplApiInstance_g, 0, sizeof(EplApiInstance_g));
 240
 241         EPL_MEMCPY(&EplApiInstance_g.m_InitParam, pInitParam_p,
 242                    min(sizeof(tEplApiInitParam),
 243                        pInitParam_p->m_uiSizeOfStruct));
 244
 245         // check event callback function pointer
 246         if (EplApiInstance_g.m_InitParam.m_pfnCbEvent == NULL) {        // application must always have an event callback function
 247                 Ret = kEplApiInvalidParam;
 248                 goto Exit;
 249         }
 250 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
 251         // init OD
 252 // FIXME
 253 //    Ret = EplObdInitRam(&ObdInitParam);
 254 //    if (Ret != kEplSuccessful)
 255 //    {
 256 //        goto Exit;
 257 //    }
 258
 259         // initialize EplObd module
 260         Ret = EplObdInit(&ObdInitParam);
 261         if (Ret != kEplSuccessful) {
 262                 goto Exit;
 263         }
 264 #endif
 265
 266 #ifndef EPL_NO_FIFO
 267         ShbError = ShbInit();
 268         if (ShbError != kShbOk) {
 269                 Ret = kEplNoResource;
 270                 goto Exit;
 271         }
 272 #endif
 273
 274         // initialize EplEventk module
 275         Ret = EplEventkInit(EplApiInstance_g.m_InitParam.m_pfnCbSync);
 276         if (Ret != kEplSuccessful) {
 277                 goto Exit;
 278         }
 279         // initialize EplEventu module
 280         Ret = EplEventuInit(EplApiProcessEvent);
 281         if (Ret != kEplSuccessful) {
 282                 goto Exit;
 283         }
 284         // init EplTimerk module
 285         Ret = EplTimerkInit();
 286         if (Ret != kEplSuccessful) {
 287                 goto Exit;
 288         }
 289         // initialize EplNmtk module before DLL
 290 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) != 0)
 291         Ret = EplNmtkInit();
 292         if (Ret != kEplSuccessful) {
 293                 goto Exit;
 294         }
 295 #endif
 296
 297         // initialize EplDllk module
 298 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
 299         EPL_MEMCPY(DllkInitParam.m_be_abSrcMac,
 300                    EplApiInstance_g.m_InitParam.m_abMacAddress, 6);
 301         Ret = EplDllkAddInstance(&DllkInitParam);
 302         if (Ret != kEplSuccessful) {
 303                 goto Exit;
 304         }
 305         // initialize EplErrorHandlerk module
 306         Ret = EplErrorHandlerkInit();
 307         if (Ret != kEplSuccessful) {
 308                 goto Exit;
 309         }
 310         // initialize EplDllkCal module
 311         Ret = EplDllkCalAddInstance();
 312         if (Ret != kEplSuccessful) {
 313                 goto Exit;
 314         }
 315 #endif
 316
 317         // initialize EplDlluCal module
 318 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLU)) != 0)
 319         Ret = EplDlluCalAddInstance();
 320         if (Ret != kEplSuccessful) {
 321                 goto Exit;
 322         }
 323 #endif
 324
 325         // initialize EplPdok module
 326 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
 327         Ret = EplPdokAddInstance();
 328         if (Ret != kEplSuccessful) {
 329                 goto Exit;
 330         }
 331
 332         Ret = EplPdokCalAddInstance();
 333         if (Ret != kEplSuccessful) {
 334                 goto Exit;
 335         }
 336 #endif
 337
 338         // initialize EplNmtCnu module
 339 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_CN)) != 0)
 340         Ret = EplNmtCnuAddInstance(EplApiInstance_g.m_InitParam.m_uiNodeId);
 341         if (Ret != kEplSuccessful) {
 342                 goto Exit;
 343         }
 344 #endif
 345
 346         // initialize EplNmtu module
 347 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0)
 348         Ret = EplNmtuInit();
 349         if (Ret != kEplSuccessful) {
 350                 goto Exit;
 351         }
 352         // register NMT event callback function
 353         Ret = EplNmtuRegisterStateChangeCb(EplApiCbNmtStateChange);
 354         if (Ret != kEplSuccessful) {
 355                 goto Exit;
 356         }
 357 #endif
 358
 359 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
 360         // initialize EplNmtMnu module
 361         Ret = EplNmtMnuInit(EplApiCbNodeEvent, EplApiCbBootEvent);
 362         if (Ret != kEplSuccessful) {
 363                 goto Exit;
 364         }
 365         // initialize EplIdentu module
 366         Ret = EplIdentuInit();
 367         if (Ret != kEplSuccessful) {
 368                 goto Exit;
 369         }
 370         // initialize EplStatusu module
 371         Ret = EplStatusuInit();
 372         if (Ret != kEplSuccessful) {
 373                 goto Exit;
 374         }
 375 #endif
 376
 377         // initialize EplLedu module
 378 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0)
 379         Ret = EplLeduInit(EplApiCbLedStateChange);
 380         if (Ret != kEplSuccessful) {
 381                 goto Exit;
 382         }
 383 #endif
 384
 385         // init SDO module
 386 #if ((((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOS)) != 0) || \
 387      (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0))
 388         // init sdo command layer
 389         Ret = EplSdoComInit();
 390         if (Ret != kEplSuccessful) {
 391                 goto Exit;
 392         }
 393 #endif
 394
 395         // the application must start NMT state machine
 396         // via EplApiExecNmtCommand(kEplNmtEventSwReset)
 397         // and thereby the whole EPL stack
 398
 399       Exit:
 400         return Ret;
 401 }
 402
 403 //---------------------------------------------------------------------------
 404 //
 405 // Function:    EplApiShutdown()
 406 //
 407 // Description: deletes an instance of EPL stack
 408 //
 409 // Parameters:  (none)
 410 //
 411 // Returns:     tEplKernel              = error code
 412 //
 413 //
 414 // State:
 415 //
 416 //---------------------------------------------------------------------------
 417
 418 tEplKernel PUBLIC EplApiShutdown(void)
 419 {
 420         tEplKernel Ret = kEplSuccessful;
 421
 422         // $$$ d.k.: check if NMT state is NMT_GS_OFF
 423
 424         // $$$ d.k.: maybe delete event queues at first, but this implies that
 425         //           no other module must not use the event queues for communication
 426         //           during shutdown.
 427
 428         // delete instance for all modules
 429
 430         // deinitialize EplSdoCom module
 431 #if ((((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOS)) != 0) || \
 432      (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0))
 433         Ret = EplSdoComDelInstance();
 434 //    PRINTF1("EplSdoComDelInstance():  0x%X\n", Ret);
 435 #endif
 436
 437         // deinitialize EplLedu module
 438 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0)
 439         Ret = EplLeduDelInstance();
 440 //    PRINTF1("EplLeduDelInstance():    0x%X\n", Ret);
 441 #endif
 442
 443 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
 444         // deinitialize EplNmtMnu module
 445         Ret = EplNmtMnuDelInstance();
 446 //    PRINTF1("EplNmtMnuDelInstance():  0x%X\n", Ret);
 447
 448         // deinitialize EplIdentu module
 449         Ret = EplIdentuDelInstance();
 450 //    PRINTF1("EplIdentuDelInstance():  0x%X\n", Ret);
 451
 452         // deinitialize EplStatusu module
 453         Ret = EplStatusuDelInstance();
 454 //    PRINTF1("EplStatusuDelInstance():  0x%X\n", Ret);
 455 #endif
 456
 457         // deinitialize EplNmtCnu module
 458 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_CN)) != 0)
 459         Ret = EplNmtCnuDelInstance();
 460 //    PRINTF1("EplNmtCnuDelInstance():  0x%X\n", Ret);
 461 #endif
 462
 463         // deinitialize EplNmtu module
 464 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0)
 465         Ret = EplNmtuDelInstance();
 466 //    PRINTF1("EplNmtuDelInstance():    0x%X\n", Ret);
 467 #endif
 468
 469         // deinitialize EplDlluCal module
 470 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLU)) != 0)
 471         Ret = EplDlluCalDelInstance();
 472 //    PRINTF1("EplDlluCalDelInstance(): 0x%X\n", Ret);
 473
 474 #endif
 475
 476         // deinitialize EplEventu module
 477         Ret = EplEventuDelInstance();
 478 //    PRINTF1("EplEventuDelInstance():  0x%X\n", Ret);
 479
 480         // deinitialize EplNmtk module
 481 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) != 0)
 482         Ret = EplNmtkDelInstance();
 483 //    PRINTF1("EplNmtkDelInstance():    0x%X\n", Ret);
 484 #endif
 485
 486         // deinitialize EplDllk module
 487 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
 488         Ret = EplDllkDelInstance();
 489 //    PRINTF1("EplDllkDelInstance():    0x%X\n", Ret);
 490
 491         // deinitialize EplDllkCal module
 492         Ret = EplDllkCalDelInstance();
 493 //    PRINTF1("EplDllkCalDelInstance(): 0x%X\n", Ret);
 494 #endif
 495
 496         // deinitialize EplEventk module
 497         Ret = EplEventkDelInstance();
 498 //    PRINTF1("EplEventkDelInstance():  0x%X\n", Ret);
 499
 500         // deinitialize EplTimerk module
 501         Ret = EplTimerkDelInstance();
 502 //    PRINTF1("EplTimerkDelInstance():  0x%X\n", Ret);
 503
 504 #ifndef EPL_NO_FIFO
 505         ShbExit();
 506 #endif
 507
 508         return Ret;
 509 }
 510
 511 //----------------------------------------------------------------------------
 512 // Function:    EplApiExecNmtCommand()
 513 //
 514 // Description: executes a NMT command, i.e. post the NMT command/event to the
 515 //              NMTk module. NMT commands which are not appropriate in the current
 516 //              NMT state are silently ignored. Please keep in mind that the
 517 //              NMT state may change until the NMT command is actually executed.
 518 //
 519 // Parameters:  NmtEvent_p              = NMT command/event
 520 //
 521 // Returns:     tEplKernel              = error code
 522 //
 523 // State:
 524 //----------------------------------------------------------------------------
 525
 526 tEplKernel PUBLIC EplApiExecNmtCommand(tEplNmtEvent NmtEvent_p)
 527 {
 528         tEplKernel Ret = kEplSuccessful;
 529
 530 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0)
 531         Ret = EplNmtuNmtEvent(NmtEvent_p);
 532 #endif
 533
 534         return Ret;
 535 }
 536
 537 //----------------------------------------------------------------------------
 538 // Function:    EplApiLinkObject()
 539 //
 540 // Description: Function maps array of application variables onto specified object in OD
 541 //
 542 // Parameters:  uiObjIndex_p            = Function maps variables for this object index
 543 //              pVar_p                  = Pointer to data memory area for the specified object
 544 //              puiVarEntries_p         = IN: pointer to number of entries to map
 545 //                                        OUT: pointer to number of actually used entries
 546 //              pEntrySize_p            = IN: pointer to size of one entry;
 547 //                                            if size is zero, the actual size will be read from OD
 548 //                                        OUT: pointer to entire size of all entries mapped
 549 //              uiFirstSubindex_p       = This is the first subindex to be mapped.
 550 //
 551 // Returns:     tEplKernel              = error code
 552 //
 553 // State:
 554 //----------------------------------------------------------------------------
 555
 556 tEplKernel PUBLIC EplApiLinkObject(unsigned int uiObjIndex_p,
 557                                    void *pVar_p,
 558                                    unsigned int *puiVarEntries_p,
 559                                    tEplObdSize * pEntrySize_p,
 560                                    unsigned int uiFirstSubindex_p)
 561 {
 562         BYTE bVarEntries;
 563         BYTE bIndexEntries;
 564         BYTE MEM *pbData;
 565         unsigned int uiSubindex;
 566         tEplVarParam VarParam;
 567         tEplObdSize EntrySize;
 568         tEplObdSize UsedSize;
 569
 570         tEplKernel RetCode = kEplSuccessful;
 571
 572         if ((pVar_p == NULL)
 573             || (puiVarEntries_p == NULL)
 574             || (*puiVarEntries_p == 0)
 575             || (pEntrySize_p == NULL)) {
 576                 RetCode = kEplApiInvalidParam;
 577                 goto Exit;
 578         }
 579
 580         pbData = (BYTE MEM *) pVar_p;
 581         bVarEntries = (BYTE) * puiVarEntries_p;
 582         UsedSize = 0;
 583
 584         // init VarParam structure with default values
 585         VarParam.m_uiIndex = uiObjIndex_p;
 586         VarParam.m_ValidFlag = kVarValidAll;
 587
 588         if (uiFirstSubindex_p != 0) {   // check if object exists by reading subindex 0x00,
 589                 // because user wants to link a variable to a subindex unequal 0x00
 590                 // read number of entries
 591                 EntrySize = (tEplObdSize) sizeof(bIndexEntries);
 592                 RetCode = EplObdReadEntry(uiObjIndex_p,
 593                                           0x00,
 594                                           (void GENERIC *)&bIndexEntries,
 595                                           &EntrySize);
 596
 597                 if ((RetCode != kEplSuccessful) || (bIndexEntries == 0x00)) {
 598                         // Object doesn't exist or invalid entry number
 599                         RetCode = kEplObdIndexNotExist;
 600                         goto Exit;
 601                 }
 602         } else {                // user wants to link a variable to subindex 0x00
 603                 // that's OK
 604                 bIndexEntries = 0;
 605         }
 606
 607         // Correct number of entries if number read from OD is greater
 608         // than the specified number.
 609         // This is done, so that we do not set more entries than subindexes the
 610         // object actually has.
 611         if ((bIndexEntries > (bVarEntries + uiFirstSubindex_p - 1)) &&
 612             (bVarEntries != 0x00)) {
 613                 bIndexEntries = (BYTE) (bVarEntries + uiFirstSubindex_p - 1);
 614         }
 615         // map entries
 616         for (uiSubindex = uiFirstSubindex_p; uiSubindex <= bIndexEntries;
 617              uiSubindex++) {
 618                 // if passed entry size is 0, then get size from OD
 619                 if (*pEntrySize_p == 0x00) {
 620                         // read entry size
 621                         EntrySize = EplObdGetDataSize(uiObjIndex_p, uiSubindex);
 622
 623                         if (EntrySize == 0x00) {
 624                                 // invalid entry size (maybe object doesn't exist or entry of type DOMAIN is empty)
 625                                 RetCode = kEplObdSubindexNotExist;
 626                                 break;
 627                         }
 628                 } else {        // use passed entry size
 629                         EntrySize = *pEntrySize_p;
 630                 }
 631
 632                 VarParam.m_uiSubindex = uiSubindex;
 633
 634                 // set pointer to user var
 635                 VarParam.m_Size = EntrySize;
 636                 VarParam.m_pData = pbData;
 637
 638                 UsedSize += EntrySize;
 639                 pbData += EntrySize;
 640
 641                 RetCode = EplObdDefineVar(&VarParam);
 642                 if (RetCode != kEplSuccessful) {
 643                         break;
 644                 }
 645         }
 646
 647         // set number of mapped entries and entry size
 648         *puiVarEntries_p = ((bIndexEntries - uiFirstSubindex_p) + 1);
 649         *pEntrySize_p = UsedSize;
 650
 651       Exit:
 652
 653         return (RetCode);
 654
 655 }
 656
 657 // ----------------------------------------------------------------------------
 658 //
 659 // Function:    EplApiReadObject()
 660 //
 661 // Description: reads the specified entry from the OD of the specified node.
 662 //              If this node is a remote node, it performs a SDO transfer, which
 663 //              means this function returns kEplApiTaskDeferred and the application
 664 //              is informed via the event callback function when the task is completed.
 665 //
 666 // Parameters:  pSdoComConHdl_p         = INOUT: pointer to SDO connection handle (may be NULL in case of local OD access)
 667 //              uiNodeId_p              = IN: node ID (0 = itself)
 668 //              uiIndex_p               = IN: index of object in OD
 669 //              uiSubindex_p            = IN: sub-index of object in OD
 670 //              pDstData_le_p           = OUT: pointer to data in little endian
 671 //              puiSize_p               = INOUT: pointer to size of data
 672 //              SdoType_p               = IN: type of SDO transfer
 673 //              pUserArg_p              = IN: user-definable argument pointer,
 674 //                                            which will be passed to the event callback function
 675 //
 676 // Return:      tEplKernel              = error code
 677 //
 678 // ----------------------------------------------------------------------------
 679
 680 tEplKernel PUBLIC EplApiReadObject(tEplSdoComConHdl * pSdoComConHdl_p,
 681                                    unsigned int uiNodeId_p,
 682                                    unsigned int uiIndex_p,
 683                                    unsigned int uiSubindex_p,
 684                                    void *pDstData_le_p,
 685                                    unsigned int *puiSize_p,
 686                                    tEplSdoType SdoType_p, void *pUserArg_p)
 687 {
 688         tEplKernel Ret = kEplSuccessful;
 689
 690         if ((uiIndex_p == 0) || (pDstData_le_p == NULL) || (puiSize_p == NULL)
 691             || (*puiSize_p == 0)) {
 692                 Ret = kEplApiInvalidParam;
 693                 goto Exit;
 694         }
 695
 696         if (uiNodeId_p == 0 || uiNodeId_p == EplObdGetNodeId()) {       // local OD access can be performed
 697                 tEplObdSize ObdSize;
 698
 699                 ObdSize = (tEplObdSize) * puiSize_p;
 700                 Ret =
 701                     EplObdReadEntryToLe(uiIndex_p, uiSubindex_p, pDstData_le_p,
 702                                         &ObdSize);
 703                 *puiSize_p = (unsigned int)ObdSize;
 704         } else {                // perform SDO transfer
 705 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
 706                 tEplSdoComTransParamByIndex TransParamByIndex;
 707 //    tEplSdoComConHdl            SdoComConHdl;
 708
 709                 // check if application provides space for handle
 710                 if (pSdoComConHdl_p == NULL) {
 711                         Ret = kEplApiInvalidParam;
 712                         goto Exit;
 713 //            pSdoComConHdl_p = &SdoComConHdl;
 714                 }
 715                 // init command layer connection
 716                 Ret = EplSdoComDefineCon(pSdoComConHdl_p, uiNodeId_p,   // target node id
 717                                          SdoType_p);    // SDO type
 718                 if ((Ret != kEplSuccessful) && (Ret != kEplSdoComHandleExists)) {
 719                         goto Exit;
 720                 }
 721                 TransParamByIndex.m_pData = pDstData_le_p;
 722                 TransParamByIndex.m_SdoAccessType = kEplSdoAccessTypeRead;
 723                 TransParamByIndex.m_SdoComConHdl = *pSdoComConHdl_p;
 724                 TransParamByIndex.m_uiDataSize = *puiSize_p;
 725                 TransParamByIndex.m_uiIndex = uiIndex_p;
 726                 TransParamByIndex.m_uiSubindex = uiSubindex_p;
 727                 TransParamByIndex.m_pfnSdoFinishedCb = EplApiCbSdoCon;
 728                 TransParamByIndex.m_pUserArg = pUserArg_p;
 729
 730                 Ret = EplSdoComInitTransferByIndex(&TransParamByIndex);
 731                 if (Ret != kEplSuccessful) {
 732                         goto Exit;
 733                 }
 734                 Ret = kEplApiTaskDeferred;
 735
 736 #else
 737                 Ret = kEplApiInvalidParam;
 738 #endif
 739         }
 740
 741       Exit:
 742         return Ret;
 743 }
 744
 745 // ----------------------------------------------------------------------------
 746 //
 747 // Function:    EplApiWriteObject()
 748 //
 749 // Description: writes the specified entry to the OD of the specified node.
 750 //              If this node is a remote node, it performs a SDO transfer, which
 751 //              means this function returns kEplApiTaskDeferred and the application
 752 //              is informed via the event callback function when the task is completed.
 753 //
 754 // Parameters:  pSdoComConHdl_p         = INOUT: pointer to SDO connection handle (may be NULL in case of local OD access)
 755 //              uiNodeId_p              = IN: node ID (0 = itself)
 756 //              uiIndex_p               = IN: index of object in OD
 757 //              uiSubindex_p            = IN: sub-index of object in OD
 758 //              pSrcData_le_p           = IN: pointer to data in little endian
 759 //              uiSize_p                = IN: size of data in bytes
 760 //              SdoType_p               = IN: type of SDO transfer
 761 //              pUserArg_p              = IN: user-definable argument pointer,
 762 //                                            which will be passed to the event callback function
 763 //
 764 // Return:      tEplKernel              = error code
 765 //
 766 // ----------------------------------------------------------------------------
 767
 768 tEplKernel PUBLIC EplApiWriteObject(tEplSdoComConHdl * pSdoComConHdl_p,
 769                                     unsigned int uiNodeId_p,
 770                                     unsigned int uiIndex_p,
 771                                     unsigned int uiSubindex_p,
 772                                     void *pSrcData_le_p,
 773                                     unsigned int uiSize_p,
 774                                     tEplSdoType SdoType_p, void *pUserArg_p)
 775 {
 776         tEplKernel Ret = kEplSuccessful;
 777
 778         if ((uiIndex_p == 0) || (pSrcData_le_p == NULL) || (uiSize_p == 0)) {
 779                 Ret = kEplApiInvalidParam;
 780                 goto Exit;
 781         }
 782
 783         if (uiNodeId_p == 0 || uiNodeId_p == EplObdGetNodeId()) {       // local OD access can be performed
 784
 785                 Ret =
 786                     EplObdWriteEntryFromLe(uiIndex_p, uiSubindex_p,
 787                                            pSrcData_le_p, uiSize_p);
 788         } else {                // perform SDO transfer
 789 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
 790                 tEplSdoComTransParamByIndex TransParamByIndex;
 791 //    tEplSdoComConHdl            SdoComConHdl;
 792
 793                 // check if application provides space for handle
 794                 if (pSdoComConHdl_p == NULL) {
 795                         Ret = kEplApiInvalidParam;
 796                         goto Exit;
 797 //            pSdoComConHdl_p = &SdoComConHdl;
 798                 }
 799                 // d.k.: How to recycle command layer connection?
 800                 //       Try to redefine it, which will return kEplSdoComHandleExists
 801                 //       and the existing command layer handle.
 802                 //       If the returned handle is busy, EplSdoComInitTransferByIndex()
 803                 //       will return with error.
 804                 // $$$ d.k.: Collisions may occur with Configuration Manager, if both the application and
 805                 //           Configuration Manager, are trying to communicate with the very same node.
 806                 //     possible solution: disallow communication by application if Configuration Manager is busy
 807
 808                 // init command layer connection
 809                 Ret = EplSdoComDefineCon(pSdoComConHdl_p, uiNodeId_p,   // target node id
 810                                          SdoType_p);    // SDO type
 811                 if ((Ret != kEplSuccessful) && (Ret != kEplSdoComHandleExists)) {
 812                         goto Exit;
 813                 }
 814                 TransParamByIndex.m_pData = pSrcData_le_p;
 815                 TransParamByIndex.m_SdoAccessType = kEplSdoAccessTypeWrite;
 816                 TransParamByIndex.m_SdoComConHdl = *pSdoComConHdl_p;
 817                 TransParamByIndex.m_uiDataSize = uiSize_p;
 818                 TransParamByIndex.m_uiIndex = uiIndex_p;
 819                 TransParamByIndex.m_uiSubindex = uiSubindex_p;
 820                 TransParamByIndex.m_pfnSdoFinishedCb = EplApiCbSdoCon;
 821                 TransParamByIndex.m_pUserArg = pUserArg_p;
 822
 823                 Ret = EplSdoComInitTransferByIndex(&TransParamByIndex);
 824                 if (Ret != kEplSuccessful) {
 825                         goto Exit;
 826                 }
 827                 Ret = kEplApiTaskDeferred;
 828
 829 #else
 830                 Ret = kEplApiInvalidParam;
 831 #endif
 832         }
 833
 834       Exit:
 835         return Ret;
 836 }
 837
 838 // ----------------------------------------------------------------------------
 839 //
 840 // Function:    EplApiFreeSdoChannel()
 841 //
 842 // Description: frees the specified SDO channel.
 843 //              This function must be called after each call to EplApiReadObject()/EplApiWriteObject()
 844 //              which returns kEplApiTaskDeferred and the application
 845 //              is informed via the event callback function when the task is completed.
 846 //
 847 // Parameters:  SdoComConHdl_p          = IN: SDO connection handle
 848 //
 849 // Return:      tEplKernel              = error code
 850 //
 851 // ----------------------------------------------------------------------------
 852
 853 tEplKernel PUBLIC EplApiFreeSdoChannel(tEplSdoComConHdl SdoComConHdl_p)
 854 {
 855         tEplKernel Ret = kEplSuccessful;
 856
 857 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
 858
 859         // init command layer connection
 860         Ret = EplSdoComUndefineCon(SdoComConHdl_p);
 861
 862 #else
 863         Ret = kEplApiInvalidParam;
 864 #endif
 865
 866         return Ret;
 867 }
 868
 869 // ----------------------------------------------------------------------------
 870 //
 871 // Function:    EplApiReadLocalObject()
 872 //
 873 // Description: reads the specified entry from the local OD.
 874 //
 875 // Parameters:  uiIndex_p               = IN: index of object in OD
 876 //              uiSubindex_p            = IN: sub-index of object in OD
 877 //              pDstData_p              = OUT: pointer to data in platform byte order
 878 //              puiSize_p               = INOUT: pointer to size of data
 879 //
 880 // Return:      tEplKernel              = error code
 881 //
 882 // ----------------------------------------------------------------------------
 883
 884 tEplKernel PUBLIC EplApiReadLocalObject(unsigned int uiIndex_p,
 885                                         unsigned int uiSubindex_p,
 886                                         void *pDstData_p,
 887                                         unsigned int *puiSize_p)
 888 {
 889         tEplKernel Ret = kEplSuccessful;
 890         tEplObdSize ObdSize;
 891
 892         ObdSize = (tEplObdSize) * puiSize_p;
 893         Ret = EplObdReadEntry(uiIndex_p, uiSubindex_p, pDstData_p, &ObdSize);
 894         *puiSize_p = (unsigned int)ObdSize;
 895
 896         return Ret;
 897 }
 898
 899 // ----------------------------------------------------------------------------
 900 //
 901 // Function:    EplApiWriteLocalObject()
 902 //
 903 // Description: writes the specified entry to the local OD.
 904 //
 905 // Parameters:  uiIndex_p               = IN: index of object in OD
 906 //              uiSubindex_p            = IN: sub-index of object in OD
 907 //              pSrcData_p              = IN: pointer to data in platform byte order
 908 //              uiSize_p                = IN: size of data in bytes
 909 //
 910 // Return:      tEplKernel              = error code
 911 //
 912 // ----------------------------------------------------------------------------
 913
 914 tEplKernel PUBLIC EplApiWriteLocalObject(unsigned int uiIndex_p,
 915                                          unsigned int uiSubindex_p,
 916                                          void *pSrcData_p,
 917                                          unsigned int uiSize_p)
 918 {
 919         tEplKernel Ret = kEplSuccessful;
 920
 921         Ret =
 922             EplObdWriteEntry(uiIndex_p, uiSubindex_p, pSrcData_p,
 923                              (tEplObdSize) uiSize_p);
 924
 925         return Ret;
 926 }
 927
 928 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
 929 // ----------------------------------------------------------------------------
 930 //
 931 // Function:    EplApiMnTriggerStateChange()
 932 //
 933 // Description: triggers the specified node command for the specified node.
 934 //
 935 // Parameters:  uiNodeId_p              = node ID for which the node command will be executed
 936 //              NodeCommand_p           = node command
 937 //
 938 // Return:      tEplKernel              = error code
 939 //
 940 // ----------------------------------------------------------------------------
 941
 942 tEplKernel PUBLIC EplApiMnTriggerStateChange(unsigned int uiNodeId_p,
 943                                              tEplNmtNodeCommand NodeCommand_p)
 944 {
 945         tEplKernel Ret = kEplSuccessful;
 946
 947         Ret = EplNmtMnuTriggerStateChange(uiNodeId_p, NodeCommand_p);
 948
 949         return Ret;
 950 }
 951
 952 #endif // (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
 953
 954 //---------------------------------------------------------------------------
 955 //
 956 // Function:    EplApiCbObdAccess
 957 //
 958 // Description: callback function for OD accesses
 959 //
 960 // Parameters:  pParam_p                = OBD parameter
 961 //
 962 // Returns:     tEplKernel              = error code
 963 //
 964 //
 965 // State:
 966 //
 967 //---------------------------------------------------------------------------
 968
 969 tEplKernel PUBLIC EplApiCbObdAccess(tEplObdCbParam MEM * pParam_p)
 970 {
 971         tEplKernel Ret = kEplSuccessful;
 972
 973 #if (EPL_API_OBD_FORWARD_EVENT != FALSE)
 974         tEplApiEventArg EventArg;
 975
 976         // call user callback
 977         // must be disabled for EplApiLinuxKernel.c, because of reentrancy problem
 978         // for local OD access. This is not so bad as user callback function in
 979         // application does not use OD callbacks at the moment.
 980         EventArg.m_ObdCbParam = *pParam_p;
 981         Ret = EplApiInstance_g.m_InitParam.m_pfnCbEvent(kEplApiEventObdAccess,
 982                                                         &EventArg,
 983                                                         EplApiInstance_g.
 984                                                         m_InitParam.
 985                                                         m_pEventUserArg);
 986 #endif
 987
 988         switch (pParam_p->m_uiIndex) {
 989                 //case 0x1006:    // NMT_CycleLen_U32 (valid on reset)
 990         case 0x1C14:            // DLL_LossOfFrameTolerance_U32
 991                 //case 0x1F98:    // NMT_CycleTiming_REC (valid on reset)
 992                 {
 993                         if (pParam_p->m_ObdEvent == kEplObdEvPostWrite) {
 994                                 // update DLL configuration
 995                                 Ret = EplApiUpdateDllConfig(FALSE);
 996                         }
 997                         break;
 998                 }
 999
1000         case 0x1020:            // CFM_VerifyConfiguration_REC.ConfId_U32 != 0
1001                 {
1002                         if ((pParam_p->m_ObdEvent == kEplObdEvPostWrite)
1003                             && (pParam_p->m_uiSubIndex == 3)
1004                             && (*((DWORD *) pParam_p->m_pArg) != 0)) {
1005                                 DWORD dwVerifyConfInvalid = 0;
1006                                 // set CFM_VerifyConfiguration_REC.VerifyConfInvalid_U32 to 0
1007                                 Ret =
1008                                     EplObdWriteEntry(0x1020, 4,
1009                                                      &dwVerifyConfInvalid, 4);
1010                                 // ignore any error because this objekt is optional
1011                                 Ret = kEplSuccessful;
1012                         }
1013                         break;
1014                 }
1015
1016         case 0x1F9E:            // NMT_ResetCmd_U8
1017                 {
1018                         if (pParam_p->m_ObdEvent == kEplObdEvPreWrite) {
1019                                 BYTE bNmtCommand;
1020
1021                                 bNmtCommand = *((BYTE *) pParam_p->m_pArg);
1022                                 // check value range
1023                                 switch ((tEplNmtCommand) bNmtCommand) {
1024                                 case kEplNmtCmdResetNode:
1025                                 case kEplNmtCmdResetCommunication:
1026                                 case kEplNmtCmdResetConfiguration:
1027                                 case kEplNmtCmdSwReset:
1028                                 case kEplNmtCmdInvalidService:
1029                                         // valid command identifier specified
1030                                         break;
1031
1032                                 default:
1033                                         pParam_p->m_dwAbortCode =
1034                                             EPL_SDOAC_VALUE_RANGE_EXCEEDED;
1035                                         Ret = kEplObdAccessViolation;
1036                                         break;
1037                                 }
1038                         } else if (pParam_p->m_ObdEvent == kEplObdEvPostWrite) {
1039                                 BYTE bNmtCommand;
1040
1041                                 bNmtCommand = *((BYTE *) pParam_p->m_pArg);
1042                                 // check value range
1043                                 switch ((tEplNmtCommand) bNmtCommand) {
1044                                 case kEplNmtCmdResetNode:
1045 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0)
1046                                         Ret =
1047                                             EplNmtuNmtEvent
1048                                             (kEplNmtEventResetNode);
1049 #endif
1050                                         break;
1051
1052                                 case kEplNmtCmdResetCommunication:
1053 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0)
1054                                         Ret =
1055                                             EplNmtuNmtEvent
1056                                             (kEplNmtEventResetCom);
1057 #endif
1058                                         break;
1059
1060                                 case kEplNmtCmdResetConfiguration:
1061 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0)
1062                                         Ret =
1063                                             EplNmtuNmtEvent
1064                                             (kEplNmtEventResetConfig);
1065 #endif
1066                                         break;
1067
1068                                 case kEplNmtCmdSwReset:
1069 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0)
1070                                         Ret =
1071                                             EplNmtuNmtEvent
1072                                             (kEplNmtEventSwReset);
1073 #endif
1074                                         break;
1075
1076                                 case kEplNmtCmdInvalidService:
1077                                         break;
1078
1079                                 default:
1080                                         pParam_p->m_dwAbortCode =
1081                                             EPL_SDOAC_VALUE_RANGE_EXCEEDED;
1082                                         Ret = kEplObdAccessViolation;
1083                                         break;
1084                                 }
1085                         }
1086                         break;
1087                 }
1088
1089         default:
1090                 break;
1091         }
1092
1093 //Exit:
1094         return Ret;
1095 }
1096
1097 //=========================================================================//
1098 //                                                                         //
1099 //          P R I V A T E   F U N C T I O N S                              //
1100 //                                                                         //
1101 //=========================================================================//
1102
1103 //---------------------------------------------------------------------------
1104 //
1105 // Function:    EplApiProcessEvent
1106 //
1107 // Description: processes events from event queue and forwards these to
1108 //              the application's event callback function
1109 //
1110 // Parameters:  pEplEvent_p =   pointer to event
1111 //
1112 // Returns:     tEplKernel  = errorcode
1113 //
1114 // State:
1115 //
1116 //---------------------------------------------------------------------------
1117
1118 static tEplKernel PUBLIC EplApiProcessEvent(tEplEvent * pEplEvent_p)
1119 {
1120         tEplKernel Ret;
1121         tEplEventError *pEventError;
1122         tEplApiEventType EventType;
1123
1124         Ret = kEplSuccessful;
1125
1126         // process event
1127         switch (pEplEvent_p->m_EventType) {
1128                 // error event
1129         case kEplEventTypeError:
1130                 {
1131                         pEventError = (tEplEventError *) pEplEvent_p->m_pArg;
1132                         switch (pEventError->m_EventSource) {
1133                                 // treat the errors from the following sources as critical
1134                         case kEplEventSourceEventk:
1135                         case kEplEventSourceEventu:
1136                         case kEplEventSourceDllk:
1137                                 {
1138                                         EventType = kEplApiEventCriticalError;
1139                                         // halt the stack by entering NMT state Off
1140                                         Ret =
1141                                             EplNmtuNmtEvent
1142                                             (kEplNmtEventCriticalError);
1143                                         break;
1144                                 }
1145
1146                                 // the other errors are just warnings
1147                         default:
1148                                 {
1149                                         EventType = kEplApiEventWarning;
1150                                         break;
1151                                 }
1152                         }
1153
1154                         // call user callback
1155                         Ret =
1156                             EplApiInstance_g.m_InitParam.m_pfnCbEvent(EventType,
1157                                                                       (tEplApiEventArg
1158                                                                        *)
1159                                                                       pEventError,
1160                                                                       EplApiInstance_g.
1161                                                                       m_InitParam.
1162                                                                       m_pEventUserArg);
1163                         // discard error from callback function, because this could generate an endless loop
1164                         Ret = kEplSuccessful;
1165                         break;
1166                 }
1167
1168                 // at present, there are no other events for this module
1169         default:
1170                 break;
1171         }
1172
1173         return Ret;
1174 }
1175
1176 //---------------------------------------------------------------------------
1177 //
1178 // Function:    EplApiCbNmtStateChange
1179 //
1180 // Description: callback function for NMT state changes
1181 //
1182 // Parameters:  NmtStateChange_p        = NMT state change event
1183 //
1184 // Returns:     tEplKernel              = error code
1185 //
1186 //
1187 // State:
1188 //
1189 //---------------------------------------------------------------------------
1190
1191 static tEplKernel PUBLIC EplApiCbNmtStateChange(tEplEventNmtStateChange
1192                                                 NmtStateChange_p)
1193 {
1194         tEplKernel Ret = kEplSuccessful;
1195         BYTE bNmtState;
1196         tEplApiEventArg EventArg;
1197
1198         // save NMT state in OD
1199         bNmtState = (BYTE) NmtStateChange_p.m_NewNmtState;
1200         Ret = EplObdWriteEntry(0x1F8C, 0, &bNmtState, 1);
1201         if (Ret != kEplSuccessful) {
1202                 goto Exit;
1203         }
1204         // do work which must be done in that state
1205         switch (NmtStateChange_p.m_NewNmtState) {
1206                 // EPL stack is not running
1207         case kEplNmtGsOff:
1208                 break;
1209
1210                 // first init of the hardware
1211         case kEplNmtGsInitialising:
1212 #if 0
1213 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDO_UDP)) != 0)
1214                 // configure SDO via UDP (i.e. bind it to the EPL ethernet interface)
1215                 Ret =
1216                     EplSdoUdpuConfig(EplApiInstance_g.m_InitParam.m_dwIpAddress,
1217                                      EPL_C_SDO_EPL_PORT);
1218                 if (Ret != kEplSuccessful) {
1219                         goto Exit;
1220                 }
1221 #endif
1222 #endif
1223
1224                 break;
1225
1226                 // init of the manufacturer-specific profile area and the
1227                 // standardised device profile area
1228         case kEplNmtGsResetApplication:
1229                 {
1230                         // reset application part of OD
1231                         Ret = EplObdAccessOdPart(kEplObdPartApp,
1232                                                  kEplObdDirLoad);
1233                         if (Ret != kEplSuccessful) {
1234                                 goto Exit;
1235                         }
1236
1237                         break;
1238                 }
1239
1240                 // init of the communication profile area
1241         case kEplNmtGsResetCommunication:
1242                 {
1243                         // reset communication part of OD
1244                         Ret = EplObdAccessOdPart(kEplObdPartGen,
1245                                                  kEplObdDirLoad);
1246
1247                         if (Ret != kEplSuccessful) {
1248                                 goto Exit;
1249                         }
1250                         // $$$ d.k.: update OD only if OD was not loaded from non-volatile memory
1251                         Ret = EplApiUpdateObd();
1252                         if (Ret != kEplSuccessful) {
1253                                 goto Exit;
1254                         }
1255
1256                         break;
1257                 }
1258
1259                 // build the configuration with infos from OD
1260         case kEplNmtGsResetConfiguration:
1261                 {
1262
1263                         Ret = EplApiUpdateDllConfig(TRUE);
1264                         if (Ret != kEplSuccessful) {
1265                                 goto Exit;
1266                         }
1267
1268                         break;
1269                 }
1270
1271                 //-----------------------------------------------------------
1272                 // CN part of the state machine
1273
1274                 // node liste for EPL-Frames and check timeout
1275         case kEplNmtCsNotActive:
1276                 {
1277                         // indicate completion of reset in NMT_ResetCmd_U8
1278                         bNmtState = (BYTE) kEplNmtCmdInvalidService;
1279                         Ret = EplObdWriteEntry(0x1F9E, 0, &bNmtState, 1);
1280                         if (Ret != kEplSuccessful) {
1281                                 goto Exit;
1282                         }
1283
1284                         break;
1285                 }
1286
1287                 // node process only async frames
1288         case kEplNmtCsPreOperational1:
1289                 {
1290                         break;
1291                 }
1292
1293                 // node process isochronus and asynchronus frames
1294         case kEplNmtCsPreOperational2:
1295                 {
1296                         break;
1297                 }
1298
1299                 // node should be configured und application is ready
1300         case kEplNmtCsReadyToOperate:
1301                 {
1302                         break;
1303                 }
1304
1305                 // normal work state
1306         case kEplNmtCsOperational:
1307                 {
1308                         break;
1309                 }
1310
1311                 // node stopped by MN
1312                 // -> only process asynchronus frames
1313         case kEplNmtCsStopped:
1314                 {
1315                         break;
1316                 }
1317
1318                 // no EPL cycle
1319                 // -> normal ethernet communication
1320         case kEplNmtCsBasicEthernet:
1321                 {
1322                         break;
1323                 }
1324
1325                 //-----------------------------------------------------------
1326                 // MN part of the state machine
1327
1328                 // node listens for EPL-Frames and check timeout
1329         case kEplNmtMsNotActive:
1330                 {
1331                         break;
1332                 }
1333
1334                 // node processes only async frames
1335         case kEplNmtMsPreOperational1:
1336                 {
1337                         break;
1338                 }
1339
1340                 // node processes isochronous and asynchronous frames
1341         case kEplNmtMsPreOperational2:
1342                 {
1343                         break;
1344                 }
1345
1346                 // node should be configured und application is ready
1347         case kEplNmtMsReadyToOperate:
1348                 {
1349                         break;
1350                 }
1351
1352                 // normal work state
1353         case kEplNmtMsOperational:
1354                 {
1355                         break;
1356                 }
1357
1358                 // no EPL cycle
1359                 // -> normal ethernet communication
1360         case kEplNmtMsBasicEthernet:
1361                 {
1362                         break;
1363                 }
1364
1365         default:
1366                 {
1367                         TRACE0
1368                             ("EplApiCbNmtStateChange(): unhandled NMT state\n");
1369                 }
1370         }
1371
1372 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0)
1373         // forward event to Led module
1374         Ret = EplLeduCbNmtStateChange(NmtStateChange_p);
1375         if (Ret != kEplSuccessful) {
1376                 goto Exit;
1377         }
1378 #endif
1379
1380 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
1381         // forward event to NmtMn module
1382         Ret = EplNmtMnuCbNmtStateChange(NmtStateChange_p);
1383         if (Ret != kEplSuccessful) {
1384                 goto Exit;
1385         }
1386 #endif
1387
1388         // call user callback
1389         EventArg.m_NmtStateChange = NmtStateChange_p;
1390         Ret =
1391             EplApiInstance_g.m_InitParam.
1392             m_pfnCbEvent(kEplApiEventNmtStateChange, &EventArg,
1393                          EplApiInstance_g.m_InitParam.m_pEventUserArg);
1394
1395       Exit:
1396         return Ret;
1397 }
1398
1399 //---------------------------------------------------------------------------
1400 //
1401 // Function:    EplApiUpdateDllConfig
1402 //
1403 // Description: update configuration of DLL
1404 //
1405 // Parameters:  fUpdateIdentity_p       = TRUE, if identity must be updated
1406 //
1407 // Returns:     tEplKernel              = error code
1408 //
1409 //
1410 // State:
1411 //
1412 //---------------------------------------------------------------------------
1413
1414 static tEplKernel PUBLIC EplApiUpdateDllConfig(BOOL fUpdateIdentity_p)
1415 {
1416         tEplKernel Ret = kEplSuccessful;
1417         tEplDllConfigParam DllConfigParam;
1418         tEplDllIdentParam DllIdentParam;
1419         tEplObdSize ObdSize;
1420         WORD wTemp;
1421         BYTE bTemp;
1422
1423         // configure Dll
1424         EPL_MEMSET(&DllConfigParam, 0, sizeof(DllConfigParam));
1425         DllConfigParam.m_uiNodeId = EplObdGetNodeId();
1426
1427         // Cycle Length (0x1006: NMT_CycleLen_U32) in [us]
1428         ObdSize = 4;
1429         Ret =
1430             EplObdReadEntry(0x1006, 0, &DllConfigParam.m_dwCycleLen, &ObdSize);
1431         if (Ret != kEplSuccessful) {
1432                 goto Exit;
1433         }
1434         // 0x1F82: NMT_FeatureFlags_U32
1435         ObdSize = 4;
1436         Ret =
1437             EplObdReadEntry(0x1F82, 0, &DllConfigParam.m_dwFeatureFlags,
1438                             &ObdSize);
1439         if (Ret != kEplSuccessful) {
1440                 goto Exit;
1441         }
1442         // d.k. There is no dependance between FeatureFlags and async-only CN
1443         DllConfigParam.m_fAsyncOnly = EplApiInstance_g.m_InitParam.m_fAsyncOnly;
1444
1445         // 0x1C14: DLL_LossOfFrameTolerance_U32 in [ns]
1446         ObdSize = 4;
1447         Ret =
1448             EplObdReadEntry(0x1C14, 0, &DllConfigParam.m_dwLossOfFrameTolerance,
1449                             &ObdSize);
1450         if (Ret != kEplSuccessful) {
1451                 goto Exit;
1452         }
1453         // 0x1F98: NMT_CycleTiming_REC
1454         // 0x1F98.1: IsochrTxMaxPayload_U16
1455         ObdSize = 2;
1456         Ret = EplObdReadEntry(0x1F98, 1, &wTemp, &ObdSize);
1457         if (Ret != kEplSuccessful) {
1458                 goto Exit;
1459         }
1460         DllConfigParam.m_uiIsochrTxMaxPayload = wTemp;
1461
1462         // 0x1F98.2: IsochrRxMaxPayload_U16
1463         ObdSize = 2;
1464         Ret = EplObdReadEntry(0x1F98, 2, &wTemp, &ObdSize);
1465         if (Ret != kEplSuccessful) {
1466                 goto Exit;
1467         }
1468         DllConfigParam.m_uiIsochrRxMaxPayload = wTemp;
1469
1470         // 0x1F98.3: PResMaxLatency_U32
1471         ObdSize = 4;
1472         Ret =
1473             EplObdReadEntry(0x1F98, 3, &DllConfigParam.m_dwPresMaxLatency,
1474                             &ObdSize);
1475         if (Ret != kEplSuccessful) {
1476                 goto Exit;
1477         }
1478         // 0x1F98.4: PReqActPayloadLimit_U16
1479         ObdSize = 2;
1480         Ret = EplObdReadEntry(0x1F98, 4, &wTemp, &ObdSize);
1481         if (Ret != kEplSuccessful) {
1482                 goto Exit;
1483         }
1484         DllConfigParam.m_uiPreqActPayloadLimit = wTemp;
1485
1486         // 0x1F98.5: PResActPayloadLimit_U16
1487         ObdSize = 2;
1488         Ret = EplObdReadEntry(0x1F98, 5, &wTemp, &ObdSize);
1489         if (Ret != kEplSuccessful) {
1490                 goto Exit;
1491         }
1492         DllConfigParam.m_uiPresActPayloadLimit = wTemp;
1493
1494         // 0x1F98.6: ASndMaxLatency_U32
1495         ObdSize = 4;
1496         Ret =
1497             EplObdReadEntry(0x1F98, 6, &DllConfigParam.m_dwAsndMaxLatency,
1498                             &ObdSize);
1499         if (Ret != kEplSuccessful) {
1500                 goto Exit;
1501         }
1502         // 0x1F98.7: MultiplCycleCnt_U8
1503         ObdSize = 1;
1504         Ret = EplObdReadEntry(0x1F98, 7, &bTemp, &ObdSize);
1505         if (Ret != kEplSuccessful) {
1506                 goto Exit;
1507         }
1508         DllConfigParam.m_uiMultiplCycleCnt = bTemp;
1509
1510         // 0x1F98.8: AsyncMTU_U16
1511         ObdSize = 2;
1512         Ret = EplObdReadEntry(0x1F98, 8, &wTemp, &ObdSize);
1513         if (Ret != kEplSuccessful) {
1514                 goto Exit;
1515         }
1516         DllConfigParam.m_uiAsyncMtu = wTemp;
1517
1518         // $$$ Prescaler
1519
1520 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
1521         // 0x1F8A.1: WaitSoCPReq_U32 in [ns]
1522         ObdSize = 4;
1523         Ret =
1524             EplObdReadEntry(0x1F8A, 1, &DllConfigParam.m_dwWaitSocPreq,
1525                             &ObdSize);
1526         if (Ret != kEplSuccessful) {
1527                 goto Exit;
1528         }
1529         // 0x1F8A.2: AsyncSlotTimeout_U32 in [ns] (optional)
1530         ObdSize = 4;
1531         Ret =
1532             EplObdReadEntry(0x1F8A, 2, &DllConfigParam.m_dwAsyncSlotTimeout,
1533                             &ObdSize);
1534 /*    if(Ret != kEplSuccessful)
1535     {
1536         goto Exit;
1537     }*/
1538 #endif
1539
1540         DllConfigParam.m_uiSizeOfStruct = sizeof(DllConfigParam);
1541         Ret = EplDllkConfig(&DllConfigParam);
1542         if (Ret != kEplSuccessful) {
1543                 goto Exit;
1544         }
1545
1546         if (fUpdateIdentity_p != FALSE) {
1547                 // configure Identity
1548                 EPL_MEMSET(&DllIdentParam, 0, sizeof(DllIdentParam));
1549                 ObdSize = 4;
1550                 Ret =
1551                     EplObdReadEntry(0x1000, 0, &DllIdentParam.m_dwDeviceType,
1552                                     &ObdSize);
1553                 if (Ret != kEplSuccessful) {
1554                         goto Exit;
1555                 }
1556
1557                 ObdSize = 4;
1558                 Ret =
1559                     EplObdReadEntry(0x1018, 1, &DllIdentParam.m_dwVendorId,
1560                                     &ObdSize);
1561                 if (Ret != kEplSuccessful) {
1562                         goto Exit;
1563                 }
1564                 ObdSize = 4;
1565                 Ret =
1566                     EplObdReadEntry(0x1018, 2, &DllIdentParam.m_dwProductCode,
1567                                     &ObdSize);
1568                 if (Ret != kEplSuccessful) {
1569                         goto Exit;
1570                 }
1571                 ObdSize = 4;
1572                 Ret =
1573                     EplObdReadEntry(0x1018, 3,
1574                                     &DllIdentParam.m_dwRevisionNumber,
1575                                     &ObdSize);
1576                 if (Ret != kEplSuccessful) {
1577                         goto Exit;
1578                 }
1579                 ObdSize = 4;
1580                 Ret =
1581                     EplObdReadEntry(0x1018, 4, &DllIdentParam.m_dwSerialNumber,
1582                                     &ObdSize);
1583                 if (Ret != kEplSuccessful) {
1584                         goto Exit;
1585                 }
1586
1587                 DllIdentParam.m_dwIpAddress =
1588                     EplApiInstance_g.m_InitParam.m_dwIpAddress;
1589                 DllIdentParam.m_dwSubnetMask =
1590                     EplApiInstance_g.m_InitParam.m_dwSubnetMask;
1591                 EPL_MEMCPY(DllIdentParam.m_sHostname,
1592                            EplApiInstance_g.m_InitParam.m_sHostname,
1593                            sizeof(DllIdentParam.m_sHostname));
1594
1595                 ObdSize = 4;
1596                 Ret =
1597                     EplObdReadEntry(0x1020, 1,
1598                                     &DllIdentParam.m_dwVerifyConfigurationDate,
1599                                     &ObdSize);
1600                 // ignore any error, because this object is optional
1601
1602                 ObdSize = 4;
1603                 Ret =
1604                     EplObdReadEntry(0x1020, 2,
1605                                     &DllIdentParam.m_dwVerifyConfigurationTime,
1606                                     &ObdSize);
1607                 // ignore any error, because this object is optional
1608
1609                 // $$$ d.k.: fill rest of ident structure
1610
1611                 DllIdentParam.m_uiSizeOfStruct = sizeof(DllIdentParam);
1612                 Ret = EplDllkSetIdentity(&DllIdentParam);
1613                 if (Ret != kEplSuccessful) {
1614                         goto Exit;
1615                 }
1616         }
1617
1618       Exit:
1619         return Ret;
1620 }
1621
1622 //---------------------------------------------------------------------------
1623 //
1624 // Function:    EplApiUpdateObd
1625 //
1626 // Description: update OD from init param
1627 //
1628 // Parameters:  (none)
1629 //
1630 // Returns:     tEplKernel              = error code
1631 //
1632 //
1633 // State:
1634 //
1635 //---------------------------------------------------------------------------
1636
1637 static tEplKernel PUBLIC EplApiUpdateObd(void)
1638 {
1639         tEplKernel Ret = kEplSuccessful;
1640         WORD wTemp;
1641         BYTE bTemp;
1642
1643         // set node id in OD
1644         Ret = EplObdSetNodeId(EplApiInstance_g.m_InitParam.m_uiNodeId,  // node id
1645                               kEplObdNodeIdHardware);   // set by hardware
1646         if (Ret != kEplSuccessful) {
1647                 goto Exit;
1648         }
1649
1650         if (EplApiInstance_g.m_InitParam.m_dwCycleLen != -1) {
1651                 Ret =
1652                     EplObdWriteEntry(0x1006, 0,
1653                                      &EplApiInstance_g.m_InitParam.m_dwCycleLen,
1654                                      4);
1655 /*    if(Ret != kEplSuccessful)
1656     {
1657         goto Exit;
1658     }*/
1659         }
1660
1661         if (EplApiInstance_g.m_InitParam.m_dwLossOfFrameTolerance != -1) {
1662                 Ret =
1663                     EplObdWriteEntry(0x1C14, 0,
1664                                      &EplApiInstance_g.m_InitParam.
1665                                      m_dwLossOfFrameTolerance, 4);
1666                 /*        if(Ret != kEplSuccessful)
1667                    {
1668                    goto Exit;
1669                    } */
1670         }
1671         // d.k. There is no dependance between FeatureFlags and async-only CN.
1672         if (EplApiInstance_g.m_InitParam.m_dwFeatureFlags != -1) {
1673                 Ret =
1674                     EplObdWriteEntry(0x1F82, 0,
1675                                      &EplApiInstance_g.m_InitParam.
1676                                      m_dwFeatureFlags, 4);
1677                 /*    if(Ret != kEplSuccessful)
1678                    {
1679                    goto Exit;
1680                    } */
1681         }
1682
1683         wTemp = (WORD) EplApiInstance_g.m_InitParam.m_uiIsochrTxMaxPayload;
1684         Ret = EplObdWriteEntry(0x1F98, 1, &wTemp, 2);
1685 /*    if(Ret != kEplSuccessful)
1686     {
1687         goto Exit;
1688     }*/
1689
1690         wTemp = (WORD) EplApiInstance_g.m_InitParam.m_uiIsochrRxMaxPayload;
1691         Ret = EplObdWriteEntry(0x1F98, 2, &wTemp, 2);
1692 /*    if(Ret != kEplSuccessful)
1693     {
1694         goto Exit;
1695     }*/
1696
1697         Ret =
1698             EplObdWriteEntry(0x1F98, 3,
1699                              &EplApiInstance_g.m_InitParam.m_dwPresMaxLatency,
1700                              4);
1701 /*    if(Ret != kEplSuccessful)
1702     {
1703         goto Exit;
1704     }*/
1705
1706         if (EplApiInstance_g.m_InitParam.m_uiPreqActPayloadLimit <=
1707             EPL_C_DLL_ISOCHR_MAX_PAYL) {
1708                 wTemp =
1709                     (WORD) EplApiInstance_g.m_InitParam.m_uiPreqActPayloadLimit;
1710                 Ret = EplObdWriteEntry(0x1F98, 4, &wTemp, 2);
1711 /*    if(Ret != kEplSuccessful)
1712     {
1713         goto Exit;
1714     }*/
1715         }
1716
1717         if (EplApiInstance_g.m_InitParam.m_uiPresActPayloadLimit <=
1718             EPL_C_DLL_ISOCHR_MAX_PAYL) {
1719                 wTemp =
1720                     (WORD) EplApiInstance_g.m_InitParam.m_uiPresActPayloadLimit;
1721                 Ret = EplObdWriteEntry(0x1F98, 5, &wTemp, 2);
1722 /*    if(Ret != kEplSuccessful)
1723     {
1724         goto Exit;
1725     }*/
1726         }
1727
1728         Ret =
1729             EplObdWriteEntry(0x1F98, 6,
1730                              &EplApiInstance_g.m_InitParam.m_dwAsndMaxLatency,
1731                              4);
1732 /*    if(Ret != kEplSuccessful)
1733     {
1734         goto Exit;
1735     }*/
1736
1737         if (EplApiInstance_g.m_InitParam.m_uiMultiplCycleCnt <= 0xFF) {
1738                 bTemp = (BYTE) EplApiInstance_g.m_InitParam.m_uiMultiplCycleCnt;
1739                 Ret = EplObdWriteEntry(0x1F98, 7, &bTemp, 1);
1740 /*    if(Ret != kEplSuccessful)
1741     {
1742         goto Exit;
1743     }*/
1744         }
1745
1746         if (EplApiInstance_g.m_InitParam.m_uiAsyncMtu <=
1747             EPL_C_DLL_MAX_ASYNC_MTU) {
1748                 wTemp = (WORD) EplApiInstance_g.m_InitParam.m_uiAsyncMtu;
1749                 Ret = EplObdWriteEntry(0x1F98, 8, &wTemp, 2);
1750 /*    if(Ret != kEplSuccessful)
1751     {
1752         goto Exit;
1753     }*/
1754         }
1755
1756         if (EplApiInstance_g.m_InitParam.m_uiPrescaler <= 1000) {
1757                 wTemp = (WORD) EplApiInstance_g.m_InitParam.m_uiPrescaler;
1758                 Ret = EplObdWriteEntry(0x1F98, 9, &wTemp, 2);
1759                 // ignore return code
1760                 Ret = kEplSuccessful;
1761         }
1762 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
1763         if (EplApiInstance_g.m_InitParam.m_dwWaitSocPreq != -1) {
1764                 Ret =
1765                     EplObdWriteEntry(0x1F8A, 1,
1766                                      &EplApiInstance_g.m_InitParam.
1767                                      m_dwWaitSocPreq, 4);
1768                 /*        if(Ret != kEplSuccessful)
1769                    {
1770                    goto Exit;
1771                    } */
1772         }
1773
1774         if ((EplApiInstance_g.m_InitParam.m_dwAsyncSlotTimeout != 0)
1775             && (EplApiInstance_g.m_InitParam.m_dwAsyncSlotTimeout != -1)) {
1776                 Ret =
1777                     EplObdWriteEntry(0x1F8A, 2,
1778                                      &EplApiInstance_g.m_InitParam.
1779                                      m_dwAsyncSlotTimeout, 4);
1780                 /*        if(Ret != kEplSuccessful)
1781                    {
1782                    goto Exit;
1783                    } */
1784         }
1785 #endif
1786
1787         // configure Identity
1788         if (EplApiInstance_g.m_InitParam.m_dwDeviceType != -1) {
1789                 Ret =
1790                     EplObdWriteEntry(0x1000, 0,
1791                                      &EplApiInstance_g.m_InitParam.
1792                                      m_dwDeviceType, 4);
1793 /*        if(Ret != kEplSuccessful)
1794         {
1795             goto Exit;
1796         }*/
1797         }
1798
1799         if (EplApiInstance_g.m_InitParam.m_dwVendorId != -1) {
1800                 Ret =
1801                     EplObdWriteEntry(0x1018, 1,
1802                                      &EplApiInstance_g.m_InitParam.m_dwVendorId,
1803                                      4);
1804 /*        if(Ret != kEplSuccessful)
1805         {
1806             goto Exit;
1807         }*/
1808         }
1809
1810         if (EplApiInstance_g.m_InitParam.m_dwProductCode != -1) {
1811                 Ret =
1812                     EplObdWriteEntry(0x1018, 2,
1813                                      &EplApiInstance_g.m_InitParam.
1814                                      m_dwProductCode, 4);
1815 /*        if(Ret != kEplSuccessful)
1816         {
1817             goto Exit;
1818         }*/
1819         }
1820
1821         if (EplApiInstance_g.m_InitParam.m_dwRevisionNumber != -1) {
1822                 Ret =
1823                     EplObdWriteEntry(0x1018, 3,
1824                                      &EplApiInstance_g.m_InitParam.
1825                                      m_dwRevisionNumber, 4);
1826 /*        if(Ret != kEplSuccessful)
1827         {
1828             goto Exit;
1829         }*/
1830         }
1831
1832         if (EplApiInstance_g.m_InitParam.m_dwSerialNumber != -1) {
1833                 Ret =
1834                     EplObdWriteEntry(0x1018, 4,
1835                                      &EplApiInstance_g.m_InitParam.
1836                                      m_dwSerialNumber, 4);
1837 /*        if(Ret != kEplSuccessful)
1838         {
1839             goto Exit;
1840         }*/
1841         }
1842
1843         if (EplApiInstance_g.m_InitParam.m_pszDevName != NULL) {
1844                 // write Device Name (0x1008)
1845                 Ret =
1846                     EplObdWriteEntry(0x1008, 0,
1847                                      (void GENERIC *)EplApiInstance_g.
1848                                      m_InitParam.m_pszDevName,
1849                                      (tEplObdSize) strlen(EplApiInstance_g.
1850                                                           m_InitParam.
1851                                                           m_pszDevName));
1852 /*        if (Ret != kEplSuccessful)
1853         {
1854             goto Exit;
1855         }*/
1856         }
1857
1858         if (EplApiInstance_g.m_InitParam.m_pszHwVersion != NULL) {
1859                 // write Hardware version (0x1009)
1860                 Ret =
1861                     EplObdWriteEntry(0x1009, 0,
1862                                      (void GENERIC *)EplApiInstance_g.
1863                                      m_InitParam.m_pszHwVersion,
1864                                      (tEplObdSize) strlen(EplApiInstance_g.
1865                                                           m_InitParam.
1866                                                           m_pszHwVersion));
1867 /*        if (Ret != kEplSuccessful)
1868         {
1869             goto Exit;
1870         }*/
1871         }
1872
1873         if (EplApiInstance_g.m_InitParam.m_pszSwVersion != NULL) {
1874                 // write Software version (0x100A)
1875                 Ret =
1876                     EplObdWriteEntry(0x100A, 0,
1877                                      (void GENERIC *)EplApiInstance_g.
1878                                      m_InitParam.m_pszSwVersion,
1879                                      (tEplObdSize) strlen(EplApiInstance_g.
1880                                                           m_InitParam.
1881                                                           m_pszSwVersion));
1882 /*        if (Ret != kEplSuccessful)
1883         {
1884             goto Exit;
1885         }*/
1886         }
1887
1888       Exit:
1889         return Ret;
1890 }
1891
1892 //---------------------------------------------------------------------------
1893 //
1894 // Function:    EplApiCbSdoCon
1895 //
1896 // Description: callback function for SDO transfers
1897 //
1898 // Parameters:  pSdoComFinished_p       = SDO parameter
1899 //
1900 // Returns:     tEplKernel              = error code
1901 //
1902 //
1903 // State:
1904 //
1905 //---------------------------------------------------------------------------
1906
1907 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
1908 static tEplKernel PUBLIC EplApiCbSdoCon(tEplSdoComFinished * pSdoComFinished_p)
1909 {
1910         tEplKernel Ret;
1911         tEplApiEventArg EventArg;
1912
1913         Ret = kEplSuccessful;
1914
1915         // call user callback
1916         EventArg.m_Sdo = *pSdoComFinished_p;
1917         Ret = EplApiInstance_g.m_InitParam.m_pfnCbEvent(kEplApiEventSdo,
1918                                                         &EventArg,
1919                                                         EplApiInstance_g.
1920                                                         m_InitParam.
1921                                                         m_pEventUserArg);
1922
1923         return Ret;
1924
1925 }
1926 #endif
1927
1928 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
1929
1930 //---------------------------------------------------------------------------
1931 //
1932 // Function:    EplApiCbNodeEvent
1933 //
1934 // Description: callback function for node events
1935 //
1936 // Parameters:  uiNodeId_p              = node ID of the CN
1937 //              NodeEvent_p             = event from the specified CN
1938 //              NmtState_p              = current NMT state of the CN
1939 //              wErrorCode_p            = EPL error code if NodeEvent_p==kEplNmtNodeEventError
1940 //              fMandatory_p            = flag if CN is mandatory
1941 //
1942 // Returns:     tEplKernel              = error code
1943 //
1944 //
1945 // State:
1946 //
1947 //---------------------------------------------------------------------------
1948
1949 static tEplKernel PUBLIC EplApiCbNodeEvent(unsigned int uiNodeId_p,
1950                                            tEplNmtNodeEvent NodeEvent_p,
1951                                            tEplNmtState NmtState_p,
1952                                            WORD wErrorCode_p, BOOL fMandatory_p)
1953 {
1954         tEplKernel Ret;
1955         tEplApiEventArg EventArg;
1956
1957         Ret = kEplSuccessful;
1958
1959         // call user callback
1960         EventArg.m_Node.m_uiNodeId = uiNodeId_p;
1961         EventArg.m_Node.m_NodeEvent = NodeEvent_p;
1962         EventArg.m_Node.m_NmtState = NmtState_p;
1963         EventArg.m_Node.m_wErrorCode = wErrorCode_p;
1964         EventArg.m_Node.m_fMandatory = fMandatory_p;
1965
1966         Ret = EplApiInstance_g.m_InitParam.m_pfnCbEvent(kEplApiEventNode,
1967                                                         &EventArg,
1968                                                         EplApiInstance_g.
1969                                                         m_InitParam.
1970                                                         m_pEventUserArg);
1971
1972         return Ret;
1973
1974 }
1975
1976 //---------------------------------------------------------------------------
1977 //
1978 // Function:    EplApiCbBootEvent
1979 //
1980 // Description: callback function for boot events
1981 //
1982 // Parameters:  BootEvent_p             = event from the boot-up process
1983 //              NmtState_p              = current local NMT state
1984 //              wErrorCode_p            = EPL error code if BootEvent_p==kEplNmtBootEventError
1985 //
1986 // Returns:     tEplKernel              = error code
1987 //
1988 //
1989 // State:
1990 //
1991 //---------------------------------------------------------------------------
1992
1993 static tEplKernel PUBLIC EplApiCbBootEvent(tEplNmtBootEvent BootEvent_p,
1994                                            tEplNmtState NmtState_p,
1995                                            WORD wErrorCode_p)
1996 {
1997         tEplKernel Ret;
1998         tEplApiEventArg EventArg;
1999
2000         Ret = kEplSuccessful;
2001
2002         // call user callback
2003         EventArg.m_Boot.m_BootEvent = BootEvent_p;
2004         EventArg.m_Boot.m_NmtState = NmtState_p;
2005         EventArg.m_Boot.m_wErrorCode = wErrorCode_p;
2006
2007         Ret = EplApiInstance_g.m_InitParam.m_pfnCbEvent(kEplApiEventBoot,
2008                                                         &EventArg,
2009                                                         EplApiInstance_g.
2010                                                         m_InitParam.
2011                                                         m_pEventUserArg);
2012
2013         return Ret;
2014
2015 }
2016
2017 #endif // (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
2018
2019 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0)
2020
2021 //---------------------------------------------------------------------------
2022 //
2023 // Function:    EplApiCbLedStateChange
2024 //
2025 // Description: callback function for LED change events.
2026 //
2027 // Parameters:  LedType_p       = type of LED
2028 //              fOn_p           = state of LED
2029 //
2030 // Returns:     tEplKernel      = errorcode
2031 //
2032 // State:
2033 //
2034 //---------------------------------------------------------------------------
2035
2036 static tEplKernel PUBLIC EplApiCbLedStateChange(tEplLedType LedType_p,
2037                                                 BOOL fOn_p)
2038 {
2039         tEplKernel Ret;
2040         tEplApiEventArg EventArg;
2041
2042         Ret = kEplSuccessful;
2043
2044         // call user callback
2045         EventArg.m_Led.m_LedType = LedType_p;
2046         EventArg.m_Led.m_fOn = fOn_p;
2047
2048         Ret = EplApiInstance_g.m_InitParam.m_pfnCbEvent(kEplApiEventLed,
2049                                                         &EventArg,
2050                                                         EplApiInstance_g.
2051                                                         m_InitParam.
2052                                                         m_pEventUserArg);
2053
2054         return Ret;
2055
2056 }
2057
2058 #endif
2059
2060 // EOF