drivers/staging/epl/EplDlluCal.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 DLL Communication Abstraction Layer module in EPL user part
   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: EplDlluCal.c,v $
  53
  54                 $Author: D.Krueger $
  55
  56                 $Revision: 1.7 $  $Date: 2008/10/17 15:32:32 $
  57
  58                 $State: Exp $
  59
  60                 Build Environment:
  61                     GCC V3.4
  62
  63   -------------------------------------------------------------------------
  64
  65   Revision History:
  66
  67   2006/06/20 d.k.:   start of the implementation, version 1.00
  68
  69 ****************************************************************************/
  70
  71 #include "user/EplDlluCal.h"
  72 #include "user/EplEventu.h"
  73
  74 #include "EplDllCal.h"
  75
  76 // include only if direct call between user- and kernelspace is enabled
  77 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
  78 #include "kernel/EplDllkCal.h"
  79 #endif
  80
  81 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLU)) != 0)
  82
  83 /***************************************************************************/
  84 /*                                                                         */
  85 /*                                                                         */
  86 /*          G L O B A L   D E F I N I T I O N S                            */
  87 /*                                                                         */
  88 /*                                                                         */
  89 /***************************************************************************/
  90
  91 //---------------------------------------------------------------------------
  92 // const defines
  93 //---------------------------------------------------------------------------
  94
  95 //---------------------------------------------------------------------------
  96 // local types
  97 //---------------------------------------------------------------------------
  98
  99 //---------------------------------------------------------------------------
 100 // modul globale vars
 101 //---------------------------------------------------------------------------
 102
 103 //---------------------------------------------------------------------------
 104 // local function prototypes
 105 //---------------------------------------------------------------------------
 106
 107 /***************************************************************************/
 108 /*                                                                         */
 109 /*                                                                         */
 110 /*          C L A S S  EplDlluCal                                          */
 111 /*                                                                         */
 112 /*                                                                         */
 113 /***************************************************************************/
 114 //
 115 // Description:
 116 //
 117 //
 118 /***************************************************************************/
 119
 120 //=========================================================================//
 121 //                                                                         //
 122 //          P R I V A T E   D E F I N I T I O N S                          //
 123 //                                                                         //
 124 //=========================================================================//
 125
 126 //---------------------------------------------------------------------------
 127 // const defines
 128 //---------------------------------------------------------------------------
 129
 130 //---------------------------------------------------------------------------
 131 // local types
 132 //---------------------------------------------------------------------------
 133
 134 typedef struct {
 135         tEplDlluCbAsnd m_apfnDlluCbAsnd[EPL_DLL_MAX_ASND_SERVICE_ID];
 136
 137 } tEplDlluCalInstance;
 138
 139 //---------------------------------------------------------------------------
 140 // local vars
 141 //---------------------------------------------------------------------------
 142
 143 // if no dynamic memory allocation shall be used
 144 // define structures statically
 145 static tEplDlluCalInstance EplDlluCalInstance_g;
 146
 147 //---------------------------------------------------------------------------
 148 // local function prototypes
 149 //---------------------------------------------------------------------------
 150
 151 static tEplKernel EplDlluCalSetAsndServiceIdFilter(tEplDllAsndServiceId
 152                                                    ServiceId_p,
 153                                                    tEplDllAsndFilter Filter_p);
 154
 155 //=========================================================================//
 156 //                                                                         //
 157 //          P U B L I C   F U N C T I O N S                                //
 158 //                                                                         //
 159 //=========================================================================//
 160
 161 //---------------------------------------------------------------------------
 162 //
 163 // Function:    EplDlluCalAddInstance()
 164 //
 165 // Description: add and initialize new instance of DLL CAL module
 166 //
 167 // Parameters:  none
 168 //
 169 // Returns:     tEplKernel              = error code
 170 //
 171 //
 172 // State:
 173 //
 174 //---------------------------------------------------------------------------
 175
 176 tEplKernel EplDlluCalAddInstance()
 177 {
 178         tEplKernel Ret = kEplSuccessful;
 179
 180         // reset instance structure
 181         EPL_MEMSET(&EplDlluCalInstance_g, 0, sizeof(EplDlluCalInstance_g));
 182
 183         return Ret;
 184 }
 185
 186 //---------------------------------------------------------------------------
 187 //
 188 // Function:    EplDlluCalDelInstance()
 189 //
 190 // Description: deletes an instance of DLL CAL module
 191 //
 192 // Parameters:  none
 193 //
 194 // Returns:     tEplKernel              = error code
 195 //
 196 //
 197 // State:
 198 //
 199 //---------------------------------------------------------------------------
 200
 201 tEplKernel EplDlluCalDelInstance()
 202 {
 203         tEplKernel Ret = kEplSuccessful;
 204
 205         // reset instance structure
 206         EPL_MEMSET(&EplDlluCalInstance_g, 0, sizeof(EplDlluCalInstance_g));
 207
 208         return Ret;
 209 }
 210
 211 //---------------------------------------------------------------------------
 212 //
 213 // Function:    EplDlluCalProcess
 214 //
 215 // Description: process the passed asynch frame
 216 //
 217 // Parameters:  pEvent_p                = event containing frame to be processed
 218 //
 219 // Returns:     tEplKernel              = error code
 220 //
 221 //
 222 // State:
 223 //
 224 //---------------------------------------------------------------------------
 225
 226 tEplKernel EplDlluCalProcess(tEplEvent * pEvent_p)
 227 {
 228         tEplKernel Ret = kEplSuccessful;
 229         tEplMsgType MsgType;
 230         unsigned int uiAsndServiceId;
 231         tEplFrameInfo FrameInfo;
 232
 233         if (pEvent_p->m_EventType == kEplEventTypeAsndRx) {
 234                 FrameInfo.m_pFrame = (tEplFrame *) pEvent_p->m_pArg;
 235                 FrameInfo.m_uiFrameSize = pEvent_p->m_uiSize;
 236                 // extract NetTime
 237                 FrameInfo.m_NetTime = pEvent_p->m_NetTime;
 238
 239                 MsgType =
 240                     (tEplMsgType) AmiGetByteFromLe(&FrameInfo.m_pFrame->
 241                                                    m_le_bMessageType);
 242                 if (MsgType != kEplMsgTypeAsnd) {
 243                         Ret = kEplInvalidOperation;
 244                         goto Exit;
 245                 }
 246
 247                 uiAsndServiceId =
 248                     (unsigned int)AmiGetByteFromLe(&FrameInfo.m_pFrame->m_Data.
 249                                                    m_Asnd.m_le_bServiceId);
 250                 if (uiAsndServiceId < EPL_DLL_MAX_ASND_SERVICE_ID) {    // ASnd service ID is valid
 251                         if (EplDlluCalInstance_g.m_apfnDlluCbAsnd[uiAsndServiceId] != NULL) {   // handler was registered
 252                                 Ret =
 253                                     EplDlluCalInstance_g.
 254                                     m_apfnDlluCbAsnd[uiAsndServiceId]
 255                                     (&FrameInfo);
 256                         }
 257                 }
 258         }
 259
 260       Exit:
 261         return Ret;
 262 }
 263
 264 //---------------------------------------------------------------------------
 265 //
 266 // Function:    EplDlluCalRegAsndService()
 267 //
 268 // Description: registers the specified handler for the specified
 269 //              AsndServiceId with the specified node ID filter.
 270 //
 271 // Parameters:  ServiceId_p             = ASnd Service ID
 272 //              pfnDlluCbAsnd_p         = callback function
 273 //              Filter_p                = node ID filter
 274 //
 275 // Returns:     tEplKernel              = error code
 276 //
 277 //
 278 // State:
 279 //
 280 //---------------------------------------------------------------------------
 281
 282 tEplKernel EplDlluCalRegAsndService(tEplDllAsndServiceId ServiceId_p,
 283                                     tEplDlluCbAsnd pfnDlluCbAsnd_p,
 284                                     tEplDllAsndFilter Filter_p)
 285 {
 286         tEplKernel Ret = kEplSuccessful;
 287
 288         if (ServiceId_p < tabentries(EplDlluCalInstance_g.m_apfnDlluCbAsnd)) {
 289                 // memorize function pointer
 290                 EplDlluCalInstance_g.m_apfnDlluCbAsnd[ServiceId_p] =
 291                     pfnDlluCbAsnd_p;
 292
 293                 if (pfnDlluCbAsnd_p == NULL) {  // close filter
 294                         Filter_p = kEplDllAsndFilterNone;
 295                 }
 296                 // set filter in DLL module in kernel part
 297                 Ret = EplDlluCalSetAsndServiceIdFilter(ServiceId_p, Filter_p);
 298
 299         }
 300
 301         return Ret;
 302 }
 303
 304 //---------------------------------------------------------------------------
 305 //
 306 // Function:    EplDlluCalAsyncSend()
 307 //
 308 // Description: sends the frame with the specified priority.
 309 //
 310 // Parameters:  pFrameInfo_p            = frame
 311 //                                        m_uiFrameSize does not include the
 312 //                                        ethernet header (14 bytes)
 313 //              Priority_p              = priority
 314 //
 315 // Returns:     tEplKernel              = error code
 316 //
 317 //
 318 // State:
 319 //
 320 //---------------------------------------------------------------------------
 321
 322 tEplKernel EplDlluCalAsyncSend(tEplFrameInfo * pFrameInfo_p,
 323                                tEplDllAsyncReqPriority Priority_p)
 324 {
 325         tEplKernel Ret = kEplSuccessful;
 326
 327 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
 328         pFrameInfo_p->m_uiFrameSize += 14;      // add size of ethernet header
 329         Ret = EplDllkCalAsyncSend(pFrameInfo_p, Priority_p);
 330 #else
 331         Ret = kEplSuccessful;
 332 #endif
 333
 334         return Ret;
 335 }
 336
 337 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
 338
 339 //---------------------------------------------------------------------------
 340 //
 341 // Function:    EplDlluCalIssueRequest()
 342 //
 343 // Description: issues a StatusRequest or a IdentRequest to the specified node.
 344 //
 345 // Parameters:  Service_p               = request service ID
 346 //              uiNodeId_p              = node ID
 347 //              bSoaFlag1_p             = flag1 for this node (transmit in SoA and PReq)
 348 //                                        If 0xFF this flag is ignored.
 349 //
 350 // Returns:     tEplKernel              = error code
 351 //
 352 //
 353 // State:
 354 //
 355 //---------------------------------------------------------------------------
 356
 357 tEplKernel EplDlluCalIssueRequest(tEplDllReqServiceId Service_p,
 358                                   unsigned int uiNodeId_p, BYTE bSoaFlag1_p)
 359 {
 360         tEplKernel Ret = kEplSuccessful;
 361
 362         // add node to appropriate request queue
 363         switch (Service_p) {
 364         case kEplDllReqServiceIdent:
 365         case kEplDllReqServiceStatus:
 366                 {
 367                         tEplEvent Event;
 368                         tEplDllCalIssueRequest IssueReq;
 369
 370                         Event.m_EventSink = kEplEventSinkDllkCal;
 371                         Event.m_EventType = kEplEventTypeDllkIssueReq;
 372                         IssueReq.m_Service = Service_p;
 373                         IssueReq.m_uiNodeId = uiNodeId_p;
 374                         IssueReq.m_bSoaFlag1 = bSoaFlag1_p;
 375                         Event.m_pArg = &IssueReq;
 376                         Event.m_uiSize = sizeof(IssueReq);
 377
 378                         Ret = EplEventuPost(&Event);
 379                         break;
 380                 }
 381
 382         default:
 383                 {
 384                         Ret = kEplDllInvalidParam;
 385                         goto Exit;
 386                 }
 387         }
 388
 389       Exit:
 390         return Ret;
 391 }
 392
 393 //---------------------------------------------------------------------------
 394 //
 395 // Function:    EplDlluCalAddNode()
 396 //
 397 // Description: adds the specified node to the isochronous phase.
 398 //
 399 // Parameters:  pNodeInfo_p             = pointer of node info structure
 400 //
 401 // Returns:     tEplKernel              = error code
 402 //
 403 //
 404 // State:
 405 //
 406 //---------------------------------------------------------------------------
 407
 408 tEplKernel EplDlluCalAddNode(tEplDllNodeInfo * pNodeInfo_p)
 409 {
 410         tEplKernel Ret = kEplSuccessful;
 411         tEplEvent Event;
 412
 413         Event.m_EventSink = kEplEventSinkDllkCal;
 414         Event.m_EventType = kEplEventTypeDllkAddNode;
 415         Event.m_pArg = pNodeInfo_p;
 416         Event.m_uiSize = sizeof(tEplDllNodeInfo);
 417
 418         Ret = EplEventuPost(&Event);
 419
 420         return Ret;
 421 }
 422
 423 //---------------------------------------------------------------------------
 424 //
 425 // Function:    EplDlluCalDeleteNode()
 426 //
 427 // Description: removes the specified node from the isochronous phase.
 428 //
 429 // Parameters:  uiNodeId_p              = node ID
 430 //
 431 // Returns:     tEplKernel              = error code
 432 //
 433 //
 434 // State:
 435 //
 436 //---------------------------------------------------------------------------
 437
 438 tEplKernel EplDlluCalDeleteNode(unsigned int uiNodeId_p)
 439 {
 440         tEplKernel Ret = kEplSuccessful;
 441         tEplEvent Event;
 442
 443         Event.m_EventSink = kEplEventSinkDllkCal;
 444         Event.m_EventType = kEplEventTypeDllkDelNode;
 445         Event.m_pArg = &uiNodeId_p;
 446         Event.m_uiSize = sizeof(uiNodeId_p);
 447
 448         Ret = EplEventuPost(&Event);
 449
 450         return Ret;
 451 }
 452
 453 //---------------------------------------------------------------------------
 454 //
 455 // Function:    EplDlluCalSoftDeleteNode()
 456 //
 457 // Description: removes the specified node softly from the isochronous phase.
 458 //
 459 // Parameters:  uiNodeId_p              = node ID
 460 //
 461 // Returns:     tEplKernel              = error code
 462 //
 463 //
 464 // State:
 465 //
 466 //---------------------------------------------------------------------------
 467
 468 tEplKernel EplDlluCalSoftDeleteNode(unsigned int uiNodeId_p)
 469 {
 470         tEplKernel Ret = kEplSuccessful;
 471         tEplEvent Event;
 472
 473         Event.m_EventSink = kEplEventSinkDllkCal;
 474         Event.m_EventType = kEplEventTypeDllkSoftDelNode;
 475         Event.m_pArg = &uiNodeId_p;
 476         Event.m_uiSize = sizeof(uiNodeId_p);
 477
 478         Ret = EplEventuPost(&Event);
 479
 480         return Ret;
 481 }
 482
 483 #endif // (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
 484
 485 //=========================================================================//
 486 //                                                                         //
 487 //          P R I V A T E   F U N C T I O N S                              //
 488 //                                                                         //
 489 //=========================================================================//
 490
 491 //---------------------------------------------------------------------------
 492 //
 493 // Function:    EplDlluCalSetAsndServiceIdFilter()
 494 //
 495 // Description: forwards call to EplDllkSetAsndServiceIdFilter() in kernel part
 496 //
 497 // Parameters:  ServiceId_p             = ASnd Service ID
 498 //              Filter_p                = node ID filter
 499 //
 500 // Returns:     tEplKernel              = error code
 501 //
 502 //
 503 // State:
 504 //
 505 //---------------------------------------------------------------------------
 506
 507 static tEplKernel EplDlluCalSetAsndServiceIdFilter(tEplDllAsndServiceId
 508                                                    ServiceId_p,
 509                                                    tEplDllAsndFilter Filter_p)
 510 {
 511         tEplKernel Ret = kEplSuccessful;
 512         tEplEvent Event;
 513         tEplDllCalAsndServiceIdFilter ServFilter;
 514
 515         Event.m_EventSink = kEplEventSinkDllkCal;
 516         Event.m_EventType = kEplEventTypeDllkServFilter;
 517         ServFilter.m_ServiceId = ServiceId_p;
 518         ServFilter.m_Filter = Filter_p;
 519         Event.m_pArg = &ServFilter;
 520         Event.m_uiSize = sizeof(ServFilter);
 521
 522         Ret = EplEventuPost(&Event);
 523
 524         return Ret;
 525 }
 526
 527 #endif // (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLU)) != 0)
 528
 529 // EOF