1 /****************************************************************************
2
3 (c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29
4 www.systec-electronic.com
5
6 Project: openPOWERLINK
7
8 Description: source file for kernel DLL Communication Abstraction Layer 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: EplDllkCal.c,v $
53
54 $Author: D.Krueger $
55
56 $Revision: 1.7 $ $Date: 2008/11/13 17:13:09 $
57
58 $State: Exp $
59
60 Build Environment:
61 GCC V3.4
62
63 -------------------------------------------------------------------------
64
65 Revision History:
66
67 2006/06/15 d.k.: start of the implementation, version 1.00
68
69 ****************************************************************************/
70
71 #include "kernel/EplDllkCal.h"
72 #include "kernel/EplDllk.h"
73 #include "kernel/EplEventk.h"
74
75 #include "EplDllCal.h"
76 #ifndef EPL_NO_FIFO
77 #include "SharedBuff.h"
78 #endif
79
80 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
81 /***************************************************************************/
82 /* */
83 /* */
84 /* G L O B A L D E F I N I T I O N S */
85 /* */
86 /* */
87 /***************************************************************************/
88
89 //---------------------------------------------------------------------------
90 // const defines
91 //---------------------------------------------------------------------------
92
93 #ifndef min
94 #define min(a,b) (((a) < (b)) ? (a) : (b))
95 #endif
96
97 //---------------------------------------------------------------------------
98 // local types
99 //---------------------------------------------------------------------------
100
101 //---------------------------------------------------------------------------
102 // modul globale vars
103 //---------------------------------------------------------------------------
104
105 //---------------------------------------------------------------------------
106 // local function prototypes
107 //---------------------------------------------------------------------------
108
109 /***************************************************************************/
110 /* */
111 /* */
112 /* C L A S S EplDllkCal */
113 /* */
114 /* */
115 /***************************************************************************/
116 //
117 // Description:
118 //
119 //
120 /***************************************************************************/
121
122 //=========================================================================//
123 // //
124 // P R I V A T E D E F I N I T I O N S //
125 // //
126 //=========================================================================//
127
128 //---------------------------------------------------------------------------
129 // const defines
130 //---------------------------------------------------------------------------
131
132 #define EPL_DLLKCAL_MAX_QUEUES 5 // CnGenReq, CnNmtReq, {MnGenReq, MnNmtReq}, MnIdentReq, MnStatusReq
133
134 //---------------------------------------------------------------------------
135 // local types
136 //---------------------------------------------------------------------------
137
138 typedef struct {
139 #ifndef EPL_NO_FIFO
140 // tShbInstance m_ShbInstanceRx; // FIFO for Rx ASnd frames
141 tShbInstance m_ShbInstanceTxNmt; // FIFO for Tx frames with NMT request priority
142 tShbInstance m_ShbInstanceTxGen; // FIFO for Tx frames with generic priority
143 #else
144 unsigned int m_uiFrameSizeNmt;
145 BYTE m_abFrameNmt[1500];
146 unsigned int m_uiFrameSizeGen;
147 BYTE m_abFrameGen[1500];
148 #endif
149
150 tEplDllkCalStatistics m_Statistics;
151
152 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
153 // IdentRequest queue with CN node IDs
154 unsigned int m_auiQueueIdentReq[EPL_D_NMT_MaxCNNumber_U8 + 1]; // 1 entry is reserved to distinguish between full and empty
155 unsigned int m_uiWriteIdentReq;
156 unsigned int m_uiReadIdentReq;
157
158 // StatusRequest queue with CN node IDs
159 unsigned int m_auiQueueStatusReq[EPL_D_NMT_MaxCNNumber_U8 + 1]; // 1 entry is reserved to distinguish between full and empty
160 unsigned int m_uiWriteStatusReq;
161 unsigned int m_uiReadStatusReq;
162
163 unsigned int m_auiQueueCnRequests[254 * 2];
164 // first 254 entries represent the generic requests of the corresponding node
165 // second 254 entries represent the NMT requests of the corresponding node
166 unsigned int m_uiNextQueueCnRequest;
167 unsigned int m_uiNextRequestQueue;
168 #endif
169
170 } tEplDllkCalInstance;
171
172 //---------------------------------------------------------------------------
173 // local vars
174 //---------------------------------------------------------------------------
175
176 // if no dynamic memory allocation shall be used
177 // define structures statically
178 static tEplDllkCalInstance EplDllkCalInstance_g;
179
180 //---------------------------------------------------------------------------
181 // local function prototypes
182 //---------------------------------------------------------------------------
183
184 //=========================================================================//
185 // //
186 // P U B L I C F U N C T I O N S //
187 // //
188 //=========================================================================//
189
190 //---------------------------------------------------------------------------
191 //
192 // Function: EplDllkCalAddInstance()
193 //
194 // Description: add and initialize new instance of DLL CAL module
195 //
196 // Parameters: none
197 //
198 // Returns: tEplKernel = error code
199 //
200 //
201 // State:
202 //
203 //---------------------------------------------------------------------------
204
EplDllkCalAddInstance()205 tEplKernel EplDllkCalAddInstance()
206 {
207 tEplKernel Ret = kEplSuccessful;
208 #ifndef EPL_NO_FIFO
209 tShbError ShbError;
210 unsigned int fShbNewCreated;
211
212 /* ShbError = ShbCirAllocBuffer (EPL_DLLCAL_BUFFER_SIZE_RX, EPL_DLLCAL_BUFFER_ID_RX,
213 &EplDllkCalInstance_g.m_ShbInstanceRx, &fShbNewCreated);
214 // returns kShbOk, kShbOpenMismatch, kShbOutOfMem or kShbInvalidArg
215
216 if (ShbError != kShbOk)
217 {
218 Ret = kEplNoResource;
219 }
220 */
221 ShbError =
222 ShbCirAllocBuffer(EPL_DLLCAL_BUFFER_SIZE_TX_NMT,
223 EPL_DLLCAL_BUFFER_ID_TX_NMT,
224 &EplDllkCalInstance_g.m_ShbInstanceTxNmt,
225 &fShbNewCreated);
226 // returns kShbOk, kShbOpenMismatch, kShbOutOfMem or kShbInvalidArg
227
228 if (ShbError != kShbOk) {
229 Ret = kEplNoResource;
230 }
231
232 /* ShbError = ShbCirSetSignalHandlerNewData (EplDllkCalInstance_g.m_ShbInstanceTxNmt, EplDllkCalTxNmtSignalHandler, kShbPriorityNormal);
233 // returns kShbOk, kShbAlreadySignaling or kShbInvalidArg
234
235 if (ShbError != kShbOk)
236 {
237 Ret = kEplNoResource;
238 }
239 */
240 ShbError =
241 ShbCirAllocBuffer(EPL_DLLCAL_BUFFER_SIZE_TX_GEN,
242 EPL_DLLCAL_BUFFER_ID_TX_GEN,
243 &EplDllkCalInstance_g.m_ShbInstanceTxGen,
244 &fShbNewCreated);
245 // returns kShbOk, kShbOpenMismatch, kShbOutOfMem or kShbInvalidArg
246
247 if (ShbError != kShbOk) {
248 Ret = kEplNoResource;
249 }
250
251 /* ShbError = ShbCirSetSignalHandlerNewData (EplDllkCalInstance_g.m_ShbInstanceTxGen, EplDllkCalTxGenSignalHandler, kShbPriorityNormal);
252 // returns kShbOk, kShbAlreadySignaling or kShbInvalidArg
253
254 if (ShbError != kShbOk)
255 {
256 Ret = kEplNoResource;
257 }
258 */
259 #else
260 EplDllkCalInstance_g.m_uiFrameSizeNmt = 0;
261 EplDllkCalInstance_g.m_uiFrameSizeGen = 0;
262 #endif
263
264 return Ret;
265 }
266
267 //---------------------------------------------------------------------------
268 //
269 // Function: EplDllkCalDelInstance()
270 //
271 // Description: deletes instance of DLL CAL module
272 //
273 // Parameters: none
274 //
275 // Returns: tEplKernel = error code
276 //
277 //
278 // State:
279 //
280 //---------------------------------------------------------------------------
281
EplDllkCalDelInstance()282 tEplKernel EplDllkCalDelInstance()
283 {
284 tEplKernel Ret = kEplSuccessful;
285 #ifndef EPL_NO_FIFO
286 tShbError ShbError;
287
288 /* ShbError = ShbCirReleaseBuffer (EplDllkCalInstance_g.m_ShbInstanceRx);
289 if (ShbError != kShbOk)
290 {
291 Ret = kEplNoResource;
292 }
293 EplDllkCalInstance_g.m_ShbInstanceRx = NULL;
294 */
295 ShbError = ShbCirReleaseBuffer(EplDllkCalInstance_g.m_ShbInstanceTxNmt);
296 if (ShbError != kShbOk) {
297 Ret = kEplNoResource;
298 }
299 EplDllkCalInstance_g.m_ShbInstanceTxNmt = NULL;
300
301 ShbError = ShbCirReleaseBuffer(EplDllkCalInstance_g.m_ShbInstanceTxGen);
302 if (ShbError != kShbOk) {
303 Ret = kEplNoResource;
304 }
305 EplDllkCalInstance_g.m_ShbInstanceTxGen = NULL;
306
307 #else
308 EplDllkCalInstance_g.m_uiFrameSizeNmt = 0;
309 EplDllkCalInstance_g.m_uiFrameSizeGen = 0;
310 #endif
311
312 return Ret;
313 }
314
315 //---------------------------------------------------------------------------
316 //
317 // Function: EplDllkCalProcess
318 //
319 // Description: process the passed configuration
320 //
321 // Parameters: pEvent_p = event containing configuration options
322 //
323 // Returns: tEplKernel = error code
324 //
325 //
326 // State:
327 //
328 //---------------------------------------------------------------------------
329
EplDllkCalProcess(tEplEvent * pEvent_p)330 tEplKernel EplDllkCalProcess(tEplEvent * pEvent_p)
331 {
332 tEplKernel Ret = kEplSuccessful;
333
334 switch (pEvent_p->m_EventType) {
335 case kEplEventTypeDllkServFilter:
336 {
337 tEplDllCalAsndServiceIdFilter *pServFilter;
338
339 pServFilter =
340 (tEplDllCalAsndServiceIdFilter *) pEvent_p->m_pArg;
341 Ret =
342 EplDllkSetAsndServiceIdFilter(pServFilter->
343 m_ServiceId,
344 pServFilter->
345 m_Filter);
346 break;
347 }
348
349 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
350 case kEplEventTypeDllkIssueReq:
351 {
352 tEplDllCalIssueRequest *pIssueReq;
353
354 pIssueReq = (tEplDllCalIssueRequest *) pEvent_p->m_pArg;
355 Ret =
356 EplDllkCalIssueRequest(pIssueReq->m_Service,
357 pIssueReq->m_uiNodeId,
358 pIssueReq->m_bSoaFlag1);
359 break;
360 }
361
362 case kEplEventTypeDllkAddNode:
363 {
364 tEplDllNodeInfo *pNodeInfo;
365
366 pNodeInfo = (tEplDllNodeInfo *) pEvent_p->m_pArg;
367 Ret = EplDllkAddNode(pNodeInfo);
368 break;
369 }
370
371 case kEplEventTypeDllkDelNode:
372 {
373 unsigned int *puiNodeId;
374
375 puiNodeId = (unsigned int *)pEvent_p->m_pArg;
376 Ret = EplDllkDeleteNode(*puiNodeId);
377 break;
378 }
379
380 case kEplEventTypeDllkSoftDelNode:
381 {
382 unsigned int *puiNodeId;
383
384 puiNodeId = (unsigned int *)pEvent_p->m_pArg;
385 Ret = EplDllkSoftDeleteNode(*puiNodeId);
386 break;
387 }
388 #endif
389
390 case kEplEventTypeDllkIdentity:
391 {
392 tEplDllIdentParam *pIdentParam;
393
394 pIdentParam = (tEplDllIdentParam *) pEvent_p->m_pArg;
395 if (pIdentParam->m_uiSizeOfStruct > pEvent_p->m_uiSize) {
396 pIdentParam->m_uiSizeOfStruct =
397 pEvent_p->m_uiSize;
398 }
399 Ret = EplDllkSetIdentity(pIdentParam);
400 break;
401 }
402
403 case kEplEventTypeDllkConfig:
404 {
405 tEplDllConfigParam *pConfigParam;
406
407 pConfigParam = (tEplDllConfigParam *) pEvent_p->m_pArg;
408 if (pConfigParam->m_uiSizeOfStruct > pEvent_p->m_uiSize) {
409 pConfigParam->m_uiSizeOfStruct =
410 pEvent_p->m_uiSize;
411 }
412 Ret = EplDllkConfig(pConfigParam);
413 break;
414 }
415
416 default:
417 break;
418 }
419
420 //Exit:
421 return Ret;
422 }
423
424 //---------------------------------------------------------------------------
425 //
426 // Function: EplDllkCalAsyncGetTxCount()
427 //
428 // Description: returns count of Tx frames of FIFO with highest priority
429 //
430 // Parameters: none
431 //
432 // Returns: tEplKernel = error code
433 //
434 //
435 // State:
436 //
437 //---------------------------------------------------------------------------
438
EplDllkCalAsyncGetTxCount(tEplDllAsyncReqPriority * pPriority_p,unsigned int * puiCount_p)439 tEplKernel EplDllkCalAsyncGetTxCount(tEplDllAsyncReqPriority * pPriority_p,
440 unsigned int *puiCount_p)
441 {
442 tEplKernel Ret = kEplSuccessful;
443 #ifndef EPL_NO_FIFO
444 tShbError ShbError;
445 unsigned long ulFrameCount;
446
447 // get frame count of Tx FIFO with NMT request priority
448 ShbError =
449 ShbCirGetReadBlockCount(EplDllkCalInstance_g.m_ShbInstanceTxNmt,
450 &ulFrameCount);
451 // returns kShbOk, kShbInvalidArg
452
453 // error handling
454 if (ShbError != kShbOk) {
455 Ret = kEplNoResource;
456 goto Exit;
457 }
458
459 if (ulFrameCount >
460 EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountNmt) {
461 EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountNmt =
462 ulFrameCount;
463 }
464
465 if (ulFrameCount != 0) { // NMT requests are in queue
466 *pPriority_p = kEplDllAsyncReqPrioNmt;
467 *puiCount_p = (unsigned int)ulFrameCount;
468 goto Exit;
469 }
470 // get frame count of Tx FIFO with generic priority
471 ShbError =
472 ShbCirGetReadBlockCount(EplDllkCalInstance_g.m_ShbInstanceTxGen,
473 &ulFrameCount);
474 // returns kShbOk, kShbInvalidArg
475
476 // error handling
477 if (ShbError != kShbOk) {
478 Ret = kEplNoResource;
479 goto Exit;
480 }
481
482 if (ulFrameCount >
483 EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountGen) {
484 EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountGen =
485 ulFrameCount;
486 }
487
488 *pPriority_p = kEplDllAsyncReqPrioGeneric;
489 *puiCount_p = (unsigned int)ulFrameCount;
490
491 Exit:
492 #else
493 if (EplDllkCalInstance_g.m_uiFrameSizeNmt > 0) {
494 *pPriority_p = kEplDllAsyncReqPrioNmt;
495 *puiCount_p = 1;
496 } else if (EplDllkCalInstance_g.m_uiFrameSizeGen > 0) {
497 *pPriority_p = kEplDllAsyncReqPrioGeneric;
498 *puiCount_p = 1;
499 } else {
500 *pPriority_p = kEplDllAsyncReqPrioGeneric;
501 *puiCount_p = 0;
502 }
503 #endif
504
505 return Ret;
506 }
507
508 //---------------------------------------------------------------------------
509 //
510 // Function: EplDllkCalAsyncGetTxFrame()
511 //
512 // Description: returns Tx frames from FIFO with specified priority
513 //
514 // Parameters: pFrame_p = IN: pointer to buffer
515 // puiFrameSize_p = IN: max size of buffer
516 // OUT: actual size of frame
517 // Priority_p = IN: priority
518 //
519 // Returns: tEplKernel = error code
520 //
521 //
522 // State:
523 //
524 //---------------------------------------------------------------------------
525
EplDllkCalAsyncGetTxFrame(void * pFrame_p,unsigned int * puiFrameSize_p,tEplDllAsyncReqPriority Priority_p)526 tEplKernel EplDllkCalAsyncGetTxFrame(void *pFrame_p,
527 unsigned int *puiFrameSize_p,
528 tEplDllAsyncReqPriority Priority_p)
529 {
530 tEplKernel Ret = kEplSuccessful;
531 #ifndef EPL_NO_FIFO
532 tShbError ShbError;
533 unsigned long ulFrameSize;
534
535 switch (Priority_p) {
536 case kEplDllAsyncReqPrioNmt: // NMT request priority
537 ShbError =
538 ShbCirReadDataBlock(EplDllkCalInstance_g.m_ShbInstanceTxNmt,
539 (BYTE *) pFrame_p, *puiFrameSize_p,
540 &ulFrameSize);
541 // returns kShbOk, kShbDataTruncated, kShbInvalidArg, kShbNoReadableData
542 break;
543
544 default: // generic priority
545 ShbError =
546 ShbCirReadDataBlock(EplDllkCalInstance_g.m_ShbInstanceTxGen,
547 (BYTE *) pFrame_p, *puiFrameSize_p,
548 &ulFrameSize);
549 // returns kShbOk, kShbDataTruncated, kShbInvalidArg, kShbNoReadableData
550 break;
551
552 }
553
554 // error handling
555 if (ShbError != kShbOk) {
556 if (ShbError == kShbNoReadableData) {
557 Ret = kEplDllAsyncTxBufferEmpty;
558 } else { // other error
559 Ret = kEplNoResource;
560 }
561 goto Exit;
562 }
563
564 *puiFrameSize_p = (unsigned int)ulFrameSize;
565
566 Exit:
567 #else
568 switch (Priority_p) {
569 case kEplDllAsyncReqPrioNmt: // NMT request priority
570 *puiFrameSize_p =
571 min(*puiFrameSize_p, EplDllkCalInstance_g.m_uiFrameSizeNmt);
572 EPL_MEMCPY(pFrame_p, EplDllkCalInstance_g.m_abFrameNmt,
573 *puiFrameSize_p);
574 EplDllkCalInstance_g.m_uiFrameSizeNmt = 0;
575 break;
576
577 default: // generic priority
578 *puiFrameSize_p =
579 min(*puiFrameSize_p, EplDllkCalInstance_g.m_uiFrameSizeGen);
580 EPL_MEMCPY(pFrame_p, EplDllkCalInstance_g.m_abFrameGen,
581 *puiFrameSize_p);
582 EplDllkCalInstance_g.m_uiFrameSizeGen = 0;
583 break;
584 }
585
586 #endif
587
588 return Ret;
589 }
590
591 //---------------------------------------------------------------------------
592 //
593 // Function: EplDllkCalAsyncFrameReceived()
594 //
595 // Description: passes ASnd frame to receive FIFO.
596 // It will be called only for frames with registered AsndServiceIds.
597 //
598 // Parameters: none
599 //
600 // Returns: tEplKernel = error code
601 //
602 //
603 // State:
604 //
605 //---------------------------------------------------------------------------
606
EplDllkCalAsyncFrameReceived(tEplFrameInfo * pFrameInfo_p)607 tEplKernel EplDllkCalAsyncFrameReceived(tEplFrameInfo * pFrameInfo_p)
608 {
609 tEplKernel Ret = kEplSuccessful;
610 tEplEvent Event;
611
612 Event.m_EventSink = kEplEventSinkDlluCal;
613 Event.m_EventType = kEplEventTypeAsndRx;
614 Event.m_pArg = pFrameInfo_p->m_pFrame;
615 Event.m_uiSize = pFrameInfo_p->m_uiFrameSize;
616 // pass NetTime of frame to userspace
617 Event.m_NetTime = pFrameInfo_p->m_NetTime;
618
619 Ret = EplEventkPost(&Event);
620 if (Ret != kEplSuccessful) {
621 EplDllkCalInstance_g.m_Statistics.m_ulCurRxFrameCount++;
622 } else {
623 EplDllkCalInstance_g.m_Statistics.m_ulMaxRxFrameCount++;
624 }
625
626 return Ret;
627 }
628
629 //---------------------------------------------------------------------------
630 //
631 // Function: EplDllkCalAsyncSend()
632 //
633 // Description: puts the given frame into the transmit FIFO with the specified
634 // priority.
635 //
636 // Parameters: pFrameInfo_p = frame info structure
637 // Priority_p = priority
638 //
639 // Returns: tEplKernel = error code
640 //
641 //
642 // State:
643 //
644 //---------------------------------------------------------------------------
645
EplDllkCalAsyncSend(tEplFrameInfo * pFrameInfo_p,tEplDllAsyncReqPriority Priority_p)646 tEplKernel EplDllkCalAsyncSend(tEplFrameInfo * pFrameInfo_p,
647 tEplDllAsyncReqPriority Priority_p)
648 {
649 tEplKernel Ret = kEplSuccessful;
650 tEplEvent Event;
651 #ifndef EPL_NO_FIFO
652 tShbError ShbError;
653
654 switch (Priority_p) {
655 case kEplDllAsyncReqPrioNmt: // NMT request priority
656 ShbError =
657 ShbCirWriteDataBlock(EplDllkCalInstance_g.
658 m_ShbInstanceTxNmt,
659 pFrameInfo_p->m_pFrame,
660 pFrameInfo_p->m_uiFrameSize);
661 // returns kShbOk, kShbExceedDataSizeLimit, kShbBufferFull, kShbInvalidArg
662 break;
663
664 default: // generic priority
665 ShbError =
666 ShbCirWriteDataBlock(EplDllkCalInstance_g.
667 m_ShbInstanceTxGen,
668 pFrameInfo_p->m_pFrame,
669 pFrameInfo_p->m_uiFrameSize);
670 // returns kShbOk, kShbExceedDataSizeLimit, kShbBufferFull, kShbInvalidArg
671 break;
672
673 }
674
675 // error handling
676 switch (ShbError) {
677 case kShbOk:
678 break;
679
680 case kShbExceedDataSizeLimit:
681 Ret = kEplDllAsyncTxBufferFull;
682 break;
683
684 case kShbBufferFull:
685 Ret = kEplDllAsyncTxBufferFull;
686 break;
687
688 case kShbInvalidArg:
689 default:
690 Ret = kEplNoResource;
691 break;
692 }
693
694 #else
695
696 switch (Priority_p) {
697 case kEplDllAsyncReqPrioNmt: // NMT request priority
698 if (EplDllkCalInstance_g.m_uiFrameSizeNmt == 0) {
699 EPL_MEMCPY(EplDllkCalInstance_g.m_abFrameNmt,
700 pFrameInfo_p->m_pFrame,
701 pFrameInfo_p->m_uiFrameSize);
702 EplDllkCalInstance_g.m_uiFrameSizeNmt =
703 pFrameInfo_p->m_uiFrameSize;
704 } else {
705 Ret = kEplDllAsyncTxBufferFull;
706 goto Exit;
707 }
708 break;
709
710 default: // generic priority
711 if (EplDllkCalInstance_g.m_uiFrameSizeGen == 0) {
712 EPL_MEMCPY(EplDllkCalInstance_g.m_abFrameGen,
713 pFrameInfo_p->m_pFrame,
714 pFrameInfo_p->m_uiFrameSize);
715 EplDllkCalInstance_g.m_uiFrameSizeGen =
716 pFrameInfo_p->m_uiFrameSize;
717 } else {
718 Ret = kEplDllAsyncTxBufferFull;
719 goto Exit;
720 }
721 break;
722 }
723
724 #endif
725
726 // post event to DLL
727 Event.m_EventSink = kEplEventSinkDllk;
728 Event.m_EventType = kEplEventTypeDllkFillTx;
729 EPL_MEMSET(&Event.m_NetTime, 0x00, sizeof(Event.m_NetTime));
730 Event.m_pArg = &Priority_p;
731 Event.m_uiSize = sizeof(Priority_p);
732 Ret = EplEventkPost(&Event);
733
734 #ifdef EPL_NO_FIFO
735 Exit:
736 #endif
737
738 return Ret;
739 }
740
741 //---------------------------------------------------------------------------
742 //
743 // Function: EplDllkCalAsyncClearBuffer()
744 //
745 // Description: clears the transmit buffer
746 //
747 // Parameters: (none)
748 //
749 // Returns: tEplKernel = error code
750 //
751 //
752 // State:
753 //
754 //---------------------------------------------------------------------------
755
EplDllkCalAsyncClearBuffer(void)756 tEplKernel EplDllkCalAsyncClearBuffer(void)
757 {
758 tEplKernel Ret = kEplSuccessful;
759 #ifndef EPL_NO_FIFO
760 tShbError ShbError;
761
762 ShbError =
763 ShbCirResetBuffer(EplDllkCalInstance_g.m_ShbInstanceTxNmt, 1000,
764 NULL);
765 ShbError =
766 ShbCirResetBuffer(EplDllkCalInstance_g.m_ShbInstanceTxGen, 1000,
767 NULL);
768
769 #else
770 EplDllkCalInstance_g.m_uiFrameSizeNmt = 0;
771 EplDllkCalInstance_g.m_uiFrameSizeGen = 0;
772 #endif
773
774 // EPL_MEMSET(&EplDllkCalInstance_g.m_Statistics, 0, sizeof (tEplDllkCalStatistics));
775 return Ret;
776 }
777
778 //---------------------------------------------------------------------------
779 //
780 // Function: EplDllkCalAsyncClearQueues()
781 //
782 // Description: clears the transmit buffer
783 //
784 // Parameters: (none)
785 //
786 // Returns: tEplKernel = error code
787 //
788 //
789 // State:
790 //
791 //---------------------------------------------------------------------------
792
793 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
EplDllkCalAsyncClearQueues(void)794 tEplKernel EplDllkCalAsyncClearQueues(void)
795 {
796 tEplKernel Ret = kEplSuccessful;
797
798 // clear MN asynchronous queues
799 EplDllkCalInstance_g.m_uiNextQueueCnRequest = 0;
800 EplDllkCalInstance_g.m_uiNextRequestQueue = 0;
801 EplDllkCalInstance_g.m_uiReadIdentReq = 0;
802 EplDllkCalInstance_g.m_uiWriteIdentReq = 0;
803 EplDllkCalInstance_g.m_uiReadStatusReq = 0;
804 EplDllkCalInstance_g.m_uiWriteStatusReq = 0;
805
806 return Ret;
807 }
808 #endif
809
810 //---------------------------------------------------------------------------
811 //
812 // Function: EplDllkCalGetStatistics()
813 //
814 // Description: returns statistics of the asynchronous queues.
815 //
816 // Parameters: ppStatistics = statistics structure
817 //
818 // Returns: tEplKernel = error code
819 //
820 //
821 // State:
822 //
823 //---------------------------------------------------------------------------
824
EplDllkCalGetStatistics(tEplDllkCalStatistics ** ppStatistics)825 tEplKernel EplDllkCalGetStatistics(tEplDllkCalStatistics ** ppStatistics)
826 {
827 tEplKernel Ret = kEplSuccessful;
828 #ifndef EPL_NO_FIFO
829 tShbError ShbError;
830
831 ShbError =
832 ShbCirGetReadBlockCount(EplDllkCalInstance_g.m_ShbInstanceTxNmt,
833 &EplDllkCalInstance_g.m_Statistics.
834 m_ulCurTxFrameCountNmt);
835 ShbError =
836 ShbCirGetReadBlockCount(EplDllkCalInstance_g.m_ShbInstanceTxGen,
837 &EplDllkCalInstance_g.m_Statistics.
838 m_ulCurTxFrameCountGen);
839 // ShbError = ShbCirGetReadBlockCount (EplDllkCalInstance_g.m_ShbInstanceRx, &EplDllkCalInstance_g.m_Statistics.m_ulCurRxFrameCount);
840
841 #else
842 if (EplDllkCalInstance_g.m_uiFrameSizeNmt > 0) {
843 EplDllkCalInstance_g.m_Statistics.m_ulCurTxFrameCountNmt = 1;
844 } else {
845 EplDllkCalInstance_g.m_Statistics.m_ulCurTxFrameCountNmt = 0;
846 }
847 if (EplDllkCalInstance_g.m_uiFrameSizeGen > 0) {
848 EplDllkCalInstance_g.m_Statistics.m_ulCurTxFrameCountGen = 1;
849 } else {
850 EplDllkCalInstance_g.m_Statistics.m_ulCurTxFrameCountGen = 0;
851 }
852 #endif
853
854 *ppStatistics = &EplDllkCalInstance_g.m_Statistics;
855 return Ret;
856 }
857
858 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
859
860 //---------------------------------------------------------------------------
861 //
862 // Function: EplDllkCalIssueRequest()
863 //
864 // Description: issues a StatusRequest or a IdentRequest to the specified node.
865 //
866 // Parameters: Service_p = request service ID
867 // uiNodeId_p = node ID
868 // bSoaFlag1_p = flag1 for this node (transmit in SoA and PReq)
869 // If 0xFF this flag is ignored.
870 //
871 // Returns: tEplKernel = error code
872 //
873 //
874 // State:
875 //
876 //---------------------------------------------------------------------------
877
EplDllkCalIssueRequest(tEplDllReqServiceId Service_p,unsigned int uiNodeId_p,BYTE bSoaFlag1_p)878 tEplKernel EplDllkCalIssueRequest(tEplDllReqServiceId Service_p,
879 unsigned int uiNodeId_p, BYTE bSoaFlag1_p)
880 {
881 tEplKernel Ret = kEplSuccessful;
882
883 if (bSoaFlag1_p != 0xFF) {
884 Ret = EplDllkSetFlag1OfNode(uiNodeId_p, bSoaFlag1_p);
885 if (Ret != kEplSuccessful) {
886 goto Exit;
887 }
888 }
889 // add node to appropriate request queue
890 switch (Service_p) {
891 case kEplDllReqServiceIdent:
892 {
893 if (((EplDllkCalInstance_g.m_uiWriteIdentReq +
894 1) %
895 tabentries(EplDllkCalInstance_g.
896 m_auiQueueIdentReq))
897 == EplDllkCalInstance_g.m_uiReadIdentReq) { // queue is full
898 Ret = kEplDllAsyncTxBufferFull;
899 goto Exit;
900 }
901 EplDllkCalInstance_g.
902 m_auiQueueIdentReq[EplDllkCalInstance_g.
903 m_uiWriteIdentReq] = uiNodeId_p;
904 EplDllkCalInstance_g.m_uiWriteIdentReq =
905 (EplDllkCalInstance_g.m_uiWriteIdentReq +
906 1) %
907 tabentries(EplDllkCalInstance_g.m_auiQueueIdentReq);
908 break;
909 }
910
911 case kEplDllReqServiceStatus:
912 {
913 if (((EplDllkCalInstance_g.m_uiWriteStatusReq +
914 1) %
915 tabentries(EplDllkCalInstance_g.
916 m_auiQueueStatusReq))
917 == EplDllkCalInstance_g.m_uiReadStatusReq) { // queue is full
918 Ret = kEplDllAsyncTxBufferFull;
919 goto Exit;
920 }
921 EplDllkCalInstance_g.
922 m_auiQueueStatusReq[EplDllkCalInstance_g.
923 m_uiWriteStatusReq] =
924 uiNodeId_p;
925 EplDllkCalInstance_g.m_uiWriteStatusReq =
926 (EplDllkCalInstance_g.m_uiWriteStatusReq +
927 1) %
928 tabentries(EplDllkCalInstance_g.
929 m_auiQueueStatusReq);
930 break;
931 }
932
933 default:
934 {
935 Ret = kEplDllInvalidParam;
936 goto Exit;
937 }
938 }
939
940 Exit:
941 return Ret;
942 }
943
944 //---------------------------------------------------------------------------
945 //
946 // Function: EplDllkCalAsyncGetSoaRequest()
947 //
948 // Description: returns next request for SoA. This function is called by DLLk module.
949 //
950 // Parameters: pReqServiceId_p = pointer to request service ID
951 // IN: available request for MN NMT or generic request queue (Flag2.PR)
952 // or kEplDllReqServiceNo if queues are empty
953 // OUT: next request
954 // puiNodeId_p = OUT: pointer to node ID of next request
955 // = EPL_C_ADR_INVALID, if request is self addressed
956 //
957 // Returns: tEplKernel = error code
958 //
959 //
960 // State:
961 //
962 //---------------------------------------------------------------------------
963
EplDllkCalAsyncGetSoaRequest(tEplDllReqServiceId * pReqServiceId_p,unsigned int * puiNodeId_p)964 tEplKernel EplDllkCalAsyncGetSoaRequest(tEplDllReqServiceId * pReqServiceId_p,
965 unsigned int *puiNodeId_p)
966 {
967 tEplKernel Ret = kEplSuccessful;
968 unsigned int uiCount;
969
970 // *pReqServiceId_p = kEplDllReqServiceNo;
971
972 for (uiCount = EPL_DLLKCAL_MAX_QUEUES; uiCount > 0; uiCount--) {
973 switch (EplDllkCalInstance_g.m_uiNextRequestQueue) {
974 case 0:
975 { // CnGenReq
976 for (;
977 EplDllkCalInstance_g.
978 m_uiNextQueueCnRequest <
979 (tabentries
980 (EplDllkCalInstance_g.
981 m_auiQueueCnRequests) / 2);
982 EplDllkCalInstance_g.
983 m_uiNextQueueCnRequest++) {
984 if (EplDllkCalInstance_g.m_auiQueueCnRequests[EplDllkCalInstance_g.m_uiNextQueueCnRequest] > 0) { // non empty queue found
985 // remove one request from queue
986 EplDllkCalInstance_g.
987 m_auiQueueCnRequests
988 [EplDllkCalInstance_g.
989 m_uiNextQueueCnRequest]--;
990 *puiNodeId_p =
991 EplDllkCalInstance_g.
992 m_uiNextQueueCnRequest + 1;
993 *pReqServiceId_p =
994 kEplDllReqServiceUnspecified;
995 EplDllkCalInstance_g.
996 m_uiNextQueueCnRequest++;
997 if (EplDllkCalInstance_g.m_uiNextQueueCnRequest >= (tabentries(EplDllkCalInstance_g.m_auiQueueCnRequests) / 2)) { // last node reached
998 // continue with CnNmtReq queue at next SoA
999 EplDllkCalInstance_g.
1000 m_uiNextRequestQueue
1001 = 1;
1002 }
1003 goto Exit;
1004 }
1005 }
1006 // all CnGenReq queues are empty -> continue with CnNmtReq queue
1007 EplDllkCalInstance_g.m_uiNextRequestQueue = 1;
1008 break;
1009 }
1010
1011 case 1:
1012 { // CnNmtReq
1013 for (;
1014 EplDllkCalInstance_g.
1015 m_uiNextQueueCnRequest <
1016 tabentries(EplDllkCalInstance_g.
1017 m_auiQueueCnRequests);
1018 EplDllkCalInstance_g.
1019 m_uiNextQueueCnRequest++) {
1020 if (EplDllkCalInstance_g.m_auiQueueCnRequests[EplDllkCalInstance_g.m_uiNextQueueCnRequest] > 0) { // non empty queue found
1021 // remove one request from queue
1022 EplDllkCalInstance_g.
1023 m_auiQueueCnRequests
1024 [EplDllkCalInstance_g.
1025 m_uiNextQueueCnRequest]--;
1026 *puiNodeId_p =
1027 EplDllkCalInstance_g.
1028 m_uiNextQueueCnRequest + 1 -
1029 (tabentries
1030 (EplDllkCalInstance_g.
1031 m_auiQueueCnRequests) /
1032 2);
1033 *pReqServiceId_p =
1034 kEplDllReqServiceNmtRequest;
1035 EplDllkCalInstance_g.
1036 m_uiNextQueueCnRequest++;
1037 if (EplDllkCalInstance_g.m_uiNextQueueCnRequest > tabentries(EplDllkCalInstance_g.m_auiQueueCnRequests)) { // last node reached
1038 // restart CnGenReq queue
1039 EplDllkCalInstance_g.
1040 m_uiNextQueueCnRequest
1041 = 0;
1042 // continue with MnGenReq queue at next SoA
1043 EplDllkCalInstance_g.
1044 m_uiNextRequestQueue
1045 = 2;
1046 }
1047 goto Exit;
1048 }
1049 }
1050 // restart CnGenReq queue
1051 EplDllkCalInstance_g.m_uiNextQueueCnRequest = 0;
1052 // all CnNmtReq queues are empty -> continue with MnGenReq queue
1053 EplDllkCalInstance_g.m_uiNextRequestQueue = 2;
1054 break;
1055 }
1056
1057 case 2:
1058 { // MnNmtReq and MnGenReq
1059 // next queue will be MnIdentReq queue
1060 EplDllkCalInstance_g.m_uiNextRequestQueue = 3;
1061 if (*pReqServiceId_p != kEplDllReqServiceNo) {
1062 *puiNodeId_p = EPL_C_ADR_INVALID; // DLLk must exchange this with the actual node ID
1063 goto Exit;
1064 }
1065 break;
1066 }
1067
1068 case 3:
1069 { // MnIdentReq
1070 // next queue will be MnStatusReq queue
1071 EplDllkCalInstance_g.m_uiNextRequestQueue = 4;
1072 if (EplDllkCalInstance_g.m_uiReadIdentReq != EplDllkCalInstance_g.m_uiWriteIdentReq) { // queue is not empty
1073 *puiNodeId_p =
1074 EplDllkCalInstance_g.
1075 m_auiQueueIdentReq
1076 [EplDllkCalInstance_g.
1077 m_uiReadIdentReq];
1078 EplDllkCalInstance_g.m_uiReadIdentReq =
1079 (EplDllkCalInstance_g.
1080 m_uiReadIdentReq +
1081 1) %
1082 tabentries(EplDllkCalInstance_g.
1083 m_auiQueueIdentReq);
1084 *pReqServiceId_p =
1085 kEplDllReqServiceIdent;
1086 goto Exit;
1087 }
1088 break;
1089 }
1090
1091 case 4:
1092 { // MnStatusReq
1093 // next queue will be CnGenReq queue
1094 EplDllkCalInstance_g.m_uiNextRequestQueue = 0;
1095 if (EplDllkCalInstance_g.m_uiReadStatusReq != EplDllkCalInstance_g.m_uiWriteStatusReq) { // queue is not empty
1096 *puiNodeId_p =
1097 EplDllkCalInstance_g.
1098 m_auiQueueStatusReq
1099 [EplDllkCalInstance_g.
1100 m_uiReadStatusReq];
1101 EplDllkCalInstance_g.m_uiReadStatusReq =
1102 (EplDllkCalInstance_g.
1103 m_uiReadStatusReq +
1104 1) %
1105 tabentries(EplDllkCalInstance_g.
1106 m_auiQueueStatusReq);
1107 *pReqServiceId_p =
1108 kEplDllReqServiceStatus;
1109 goto Exit;
1110 }
1111 break;
1112 }
1113
1114 }
1115 }
1116
1117 Exit:
1118 return Ret;
1119 }
1120
1121 //---------------------------------------------------------------------------
1122 //
1123 // Function: EplDllkCalAsyncSetPendingRequests()
1124 //
1125 // Description: sets the pending asynchronous frame requests of the specified node.
1126 // This will add the node to the asynchronous request scheduler.
1127 //
1128 // Parameters: uiNodeId_p = node ID
1129 // AsyncReqPrio_p = asynchronous request priority
1130 // uiCount_p = count of asynchronous frames
1131 //
1132 // Returns: tEplKernel = error code
1133 //
1134 //
1135 // State:
1136 //
1137 //---------------------------------------------------------------------------
1138
EplDllkCalAsyncSetPendingRequests(unsigned int uiNodeId_p,tEplDllAsyncReqPriority AsyncReqPrio_p,unsigned int uiCount_p)1139 tEplKernel EplDllkCalAsyncSetPendingRequests(unsigned int uiNodeId_p,
1140 tEplDllAsyncReqPriority
1141 AsyncReqPrio_p,
1142 unsigned int uiCount_p)
1143 {
1144 tEplKernel Ret = kEplSuccessful;
1145
1146 // add node to appropriate request queue
1147 switch (AsyncReqPrio_p) {
1148 case kEplDllAsyncReqPrioNmt:
1149 {
1150 uiNodeId_p--;
1151 if (uiNodeId_p >=
1152 (tabentries
1153 (EplDllkCalInstance_g.m_auiQueueCnRequests) / 2)) {
1154 Ret = kEplDllInvalidParam;
1155 goto Exit;
1156 }
1157 uiNodeId_p +=
1158 tabentries(EplDllkCalInstance_g.
1159 m_auiQueueCnRequests) / 2;
1160 EplDllkCalInstance_g.m_auiQueueCnRequests[uiNodeId_p] =
1161 uiCount_p;
1162 break;
1163 }
1164
1165 default:
1166 {
1167 uiNodeId_p--;
1168 if (uiNodeId_p >=
1169 (tabentries
1170 (EplDllkCalInstance_g.m_auiQueueCnRequests) / 2)) {
1171 Ret = kEplDllInvalidParam;
1172 goto Exit;
1173 }
1174 EplDllkCalInstance_g.m_auiQueueCnRequests[uiNodeId_p] =
1175 uiCount_p;
1176 break;
1177 }
1178 }
1179
1180 Exit:
1181 return Ret;
1182 }
1183 #endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
1184
1185 //=========================================================================//
1186 // //
1187 // P R I V A T E F U N C T I O N S //
1188 // //
1189 //=========================================================================//
1190
1191 //---------------------------------------------------------------------------
1192 // Callback handler for new data signaling
1193 //---------------------------------------------------------------------------
1194
1195 #ifndef EPL_NO_FIFO
1196 /*static void EplDllkCalTxNmtSignalHandler (
1197 tShbInstance pShbRxInstance_p,
1198 unsigned long ulDataSize_p)
1199 {
1200 tEplKernel Ret = kEplSuccessful;
1201 tEplEvent Event;
1202 tEplDllAsyncReqPriority Priority;
1203 #ifndef EPL_NO_FIFO
1204 tShbError ShbError;
1205 unsigned long ulBlockCount;
1206
1207 ShbError = ShbCirGetReadBlockCount (EplDllkCalInstance_g.m_ShbInstanceTxNmt, &ulBlockCount);
1208 if (ulBlockCount > EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountNmt)
1209 {
1210 EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountNmt = ulBlockCount;
1211 }
1212
1213 #endif
1214
1215 // post event to DLL
1216 Priority = kEplDllAsyncReqPrioNmt;
1217 Event.m_EventSink = kEplEventSinkDllk;
1218 Event.m_EventType = kEplEventTypeDllkFillTx;
1219 EPL_MEMSET(&Event.m_NetTime, 0x00, sizeof(Event.m_NetTime));
1220 Event.m_pArg = &Priority;
1221 Event.m_uiSize = sizeof(Priority);
1222 Ret = EplEventkPost(&Event);
1223
1224 }
1225
1226 static void EplDllkCalTxGenSignalHandler (
1227 tShbInstance pShbRxInstance_p,
1228 unsigned long ulDataSize_p)
1229 {
1230 tEplKernel Ret = kEplSuccessful;
1231 tEplEvent Event;
1232 tEplDllAsyncReqPriority Priority;
1233 #ifndef EPL_NO_FIFO
1234 tShbError ShbError;
1235 unsigned long ulBlockCount;
1236
1237 ShbError = ShbCirGetReadBlockCount (EplDllkCalInstance_g.m_ShbInstanceTxGen, &ulBlockCount);
1238 if (ulBlockCount > EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountGen)
1239 {
1240 EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountGen = ulBlockCount;
1241 }
1242
1243 #endif
1244
1245 // post event to DLL
1246 Priority = kEplDllAsyncReqPrioGeneric;
1247 Event.m_EventSink = kEplEventSinkDllk;
1248 Event.m_EventType = kEplEventTypeDllkFillTx;
1249 EPL_MEMSET(&Event.m_NetTime, 0x00, sizeof(Event.m_NetTime));
1250 Event.m_pArg = &Priority;
1251 Event.m_uiSize = sizeof(Priority);
1252 Ret = EplEventkPost(&Event);
1253
1254 }
1255 */
1256 #endif
1257
1258 #endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
1259
1260 // EOF
1261