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 Epl-Kernelspace-Event-Modul
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: EplEventk.c,v $
53
54 $Author: D.Krueger $
55
56 $Revision: 1.9 $ $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 k.t.: start of the implementation
68
69 ****************************************************************************/
70
71 #include "kernel/EplEventk.h"
72 #include "kernel/EplNmtk.h"
73 #include "kernel/EplDllk.h"
74 #include "kernel/EplDllkCal.h"
75 #include "kernel/EplErrorHandlerk.h"
76 #include "Benchmark.h"
77
78 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
79 #include "kernel/EplPdok.h"
80 #include "kernel/EplPdokCal.h"
81 #endif
82
83 #ifdef EPL_NO_FIFO
84 #include "user/EplEventu.h"
85 #else
86 #include "SharedBuff.h"
87 #endif
88
89 /***************************************************************************/
90 /* */
91 /* */
92 /* G L O B A L D E F I N I T I O N S */
93 /* */
94 /* */
95 /***************************************************************************/
96
97 //---------------------------------------------------------------------------
98 // const defines
99 //---------------------------------------------------------------------------
100
101 // TracePoint support for realtime-debugging
102 #ifdef _DBG_TRACE_POINTS_
103 void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
104 void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p);
105 #define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p)
106 #define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v)
107 #else
108 #define TGT_DBG_SIGNAL_TRACE_POINT(p)
109 #define TGT_DBG_POST_TRACE_VALUE(v)
110 #endif
111
112 //---------------------------------------------------------------------------
113 // local types
114 //---------------------------------------------------------------------------
115
116 typedef struct {
117 #ifndef EPL_NO_FIFO
118 tShbInstance m_pShbKernelToUserInstance;
119 tShbInstance m_pShbUserToKernelInstance;
120 #else
121
122 #endif
123 tEplSyncCb m_pfnCbSync;
124 unsigned int m_uiUserToKernelFullCount;
125
126 } tEplEventkInstance;
127
128 //---------------------------------------------------------------------------
129 // modul globale vars
130 //---------------------------------------------------------------------------
131 static tEplEventkInstance EplEventkInstance_g;
132 //---------------------------------------------------------------------------
133 // local function prototypes
134 //---------------------------------------------------------------------------
135
136 // callback function for incoming events
137 #ifndef EPL_NO_FIFO
138 static void EplEventkRxSignalHandlerCb(tShbInstance pShbRxInstance_p,
139 unsigned long ulDataSize_p);
140 #endif
141
142 /***************************************************************************/
143 /* */
144 /* */
145 /* C L A S S <Epl-Kernelspace-Event> */
146 /* */
147 /* */
148 /***************************************************************************/
149 //
150 // Description:
151 //
152 //
153 /***************************************************************************/
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: EplEventkInit
164 //
165 // Description: function initializes the first instance
166 //
167 // Parameters: pfnCbSync_p = callback-function for sync event
168 //
169 // Returns: tEpKernel = errorcode
170 //
171 // State:
172 //
173 //---------------------------------------------------------------------------
174
EplEventkInit(tEplSyncCb pfnCbSync_p)175 tEplKernel PUBLIC EplEventkInit(tEplSyncCb pfnCbSync_p)
176 {
177 tEplKernel Ret;
178
179 Ret = EplEventkAddInstance(pfnCbSync_p);
180
181 return Ret;
182
183 }
184
185 //---------------------------------------------------------------------------
186 //
187 // Function: EplEventkAddInstance
188 //
189 // Description: function adds one more instance
190 //
191 // Parameters: pfnCbSync_p = callback-function for sync event
192 //
193 // Returns: tEpKernel = errorcode
194 //
195 // State:
196 //
197 //---------------------------------------------------------------------------
198
EplEventkAddInstance(tEplSyncCb pfnCbSync_p)199 tEplKernel PUBLIC EplEventkAddInstance(tEplSyncCb pfnCbSync_p)
200 {
201 tEplKernel Ret;
202 #ifndef EPL_NO_FIFO
203 tShbError ShbError;
204 unsigned int fShbNewCreated;
205 #endif
206
207 Ret = kEplSuccessful;
208
209 // init instance structure
210 EplEventkInstance_g.m_uiUserToKernelFullCount = 0;
211
212 // save cb-function
213 EplEventkInstance_g.m_pfnCbSync = pfnCbSync_p;
214
215 #ifndef EPL_NO_FIFO
216 // init shared loop buffer
217 // kernel -> user
218 ShbError = ShbCirAllocBuffer(EPL_EVENT_SIZE_SHB_KERNEL_TO_USER,
219 EPL_EVENT_NAME_SHB_KERNEL_TO_USER,
220 &EplEventkInstance_g.
221 m_pShbKernelToUserInstance,
222 &fShbNewCreated);
223 if (ShbError != kShbOk) {
224 EPL_DBGLVL_EVENTK_TRACE1
225 ("EplEventkAddInstance(): ShbCirAllocBuffer(K2U) -> 0x%X\n",
226 ShbError);
227 Ret = kEplNoResource;
228 goto Exit;
229 }
230 // user -> kernel
231 ShbError = ShbCirAllocBuffer(EPL_EVENT_SIZE_SHB_USER_TO_KERNEL,
232 EPL_EVENT_NAME_SHB_USER_TO_KERNEL,
233 &EplEventkInstance_g.
234 m_pShbUserToKernelInstance,
235 &fShbNewCreated);
236 if (ShbError != kShbOk) {
237 EPL_DBGLVL_EVENTK_TRACE1
238 ("EplEventkAddInstance(): ShbCirAllocBuffer(U2K) -> 0x%X\n",
239 ShbError);
240 Ret = kEplNoResource;
241 goto Exit;
242 }
243 // register eventhandler
244 ShbError =
245 ShbCirSetSignalHandlerNewData(EplEventkInstance_g.
246 m_pShbUserToKernelInstance,
247 EplEventkRxSignalHandlerCb,
248 kshbPriorityHigh);
249 if (ShbError != kShbOk) {
250 EPL_DBGLVL_EVENTK_TRACE1
251 ("EplEventkAddInstance(): ShbCirSetSignalHandlerNewData(U2K) -> 0x%X\n",
252 ShbError);
253 Ret = kEplNoResource;
254 goto Exit;
255 }
256
257 Exit:
258 #endif
259
260 return Ret;
261
262 }
263
264 //---------------------------------------------------------------------------
265 //
266 // Function: EplEventkDelInstance
267 //
268 // Description: function deletes instance and frees the buffers
269 //
270 // Parameters: void
271 //
272 // Returns: tEpKernel = errorcode
273 //
274 // State:
275 //
276 //---------------------------------------------------------------------------
277
EplEventkDelInstance()278 tEplKernel PUBLIC EplEventkDelInstance()
279 {
280 tEplKernel Ret;
281 #ifndef EPL_NO_FIFO
282 tShbError ShbError;
283 #endif
284
285 Ret = kEplSuccessful;
286
287 #ifndef EPL_NO_FIFO
288 // set eventhandler to NULL
289 ShbError =
290 ShbCirSetSignalHandlerNewData(EplEventkInstance_g.
291 m_pShbUserToKernelInstance, NULL,
292 kShbPriorityNormal);
293 if (ShbError != kShbOk) {
294 EPL_DBGLVL_EVENTK_TRACE1
295 ("EplEventkDelInstance(): ShbCirSetSignalHandlerNewData(U2K) -> 0x%X\n",
296 ShbError);
297 Ret = kEplNoResource;
298 }
299 // free buffer User -> Kernel
300 ShbError =
301 ShbCirReleaseBuffer(EplEventkInstance_g.m_pShbUserToKernelInstance);
302 if (ShbError != kShbOk) {
303 EPL_DBGLVL_EVENTK_TRACE1
304 ("EplEventkDelInstance(): ShbCirReleaseBuffer(U2K) -> 0x%X\n",
305 ShbError);
306 Ret = kEplNoResource;
307 } else {
308 EplEventkInstance_g.m_pShbUserToKernelInstance = NULL;
309 }
310
311 // free buffer Kernel -> User
312 ShbError =
313 ShbCirReleaseBuffer(EplEventkInstance_g.m_pShbKernelToUserInstance);
314 if (ShbError != kShbOk) {
315 EPL_DBGLVL_EVENTK_TRACE1
316 ("EplEventkDelInstance(): ShbCirReleaseBuffer(K2U) -> 0x%X\n",
317 ShbError);
318 Ret = kEplNoResource;
319 } else {
320 EplEventkInstance_g.m_pShbKernelToUserInstance = NULL;
321 }
322 #endif
323
324 return Ret;
325
326 }
327
328 //---------------------------------------------------------------------------
329 //
330 // Function: EplEventkProcess
331 //
332 // Description: Kernelthread that dispatches events in kernel part
333 //
334 // Parameters: pEvent_p = pointer to event-structure from buffer
335 //
336 // Returns: tEpKernel = errorcode
337 //
338 // State:
339 //
340 //---------------------------------------------------------------------------
341
EplEventkProcess(tEplEvent * pEvent_p)342 tEplKernel PUBLIC EplEventkProcess(tEplEvent * pEvent_p)
343 {
344 tEplKernel Ret;
345 tEplEventSource EventSource;
346
347 Ret = kEplSuccessful;
348
349 // error handling if event queue is full
350 if (EplEventkInstance_g.m_uiUserToKernelFullCount > 0) { // UserToKernel event queue has run out of space -> kEplNmtEventInternComError
351 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) != 0)
352 tEplEvent Event;
353 tEplNmtEvent NmtEvent;
354 #endif
355 #ifndef EPL_NO_FIFO
356 tShbError ShbError;
357 #endif
358
359 // directly call NMTk process function, because event queue is full
360 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) != 0)
361 NmtEvent = kEplNmtEventInternComError;
362 Event.m_EventSink = kEplEventSinkNmtk;
363 Event.m_NetTime.m_dwNanoSec = 0;
364 Event.m_NetTime.m_dwSec = 0;
365 Event.m_EventType = kEplEventTypeNmtEvent;
366 Event.m_pArg = &NmtEvent;
367 Event.m_uiSize = sizeof(NmtEvent);
368 Ret = EplNmtkProcess(&Event);
369 #endif
370
371 // NMT state machine changed to reset (i.e. NMT_GS_RESET_COMMUNICATION)
372 // now, it is safe to reset the counter and empty the event queue
373 #ifndef EPL_NO_FIFO
374 ShbError =
375 ShbCirResetBuffer(EplEventkInstance_g.
376 m_pShbUserToKernelInstance, 1000, NULL);
377 #endif
378
379 EplEventkInstance_g.m_uiUserToKernelFullCount = 0;
380 TGT_DBG_SIGNAL_TRACE_POINT(22);
381
382 // also discard the current event (it doesn't matter if we lose another event)
383 goto Exit;
384 }
385 // check m_EventSink
386 switch (pEvent_p->m_EventSink) {
387 case kEplEventSinkSync:
388 {
389 if (EplEventkInstance_g.m_pfnCbSync != NULL) {
390 Ret = EplEventkInstance_g.m_pfnCbSync();
391 if (Ret == kEplSuccessful) {
392 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
393 // mark TPDOs as valid
394 Ret = EplPdokCalSetTpdosValid(TRUE);
395 #endif
396 } else if ((Ret != kEplReject)
397 && (Ret != kEplShutdown)) {
398 EventSource = kEplEventSourceSyncCb;
399
400 // Error event for API layer
401 EplEventkPostError
402 (kEplEventSourceEventk, Ret,
403 sizeof(EventSource), &EventSource);
404 }
405 }
406 break;
407 }
408
409 // NMT-Kernel-Modul
410 case kEplEventSinkNmtk:
411 {
412 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) != 0)
413 Ret = EplNmtkProcess(pEvent_p);
414 if ((Ret != kEplSuccessful) && (Ret != kEplShutdown)) {
415 EventSource = kEplEventSourceNmtk;
416
417 // Error event for API layer
418 EplEventkPostError(kEplEventSourceEventk,
419 Ret,
420 sizeof(EventSource),
421 &EventSource);
422 }
423 #endif
424 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
425 if ((pEvent_p->m_EventType == kEplEventTypeNmtEvent)
426 &&
427 ((*((tEplNmtEvent *) pEvent_p->m_pArg) ==
428 kEplNmtEventDllCeSoa)
429 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
430 || (*((tEplNmtEvent *) pEvent_p->m_pArg) ==
431 kEplNmtEventDllMeSoaSent)
432 #endif
433 )) { // forward SoA event to error handler
434 Ret = EplErrorHandlerkProcess(pEvent_p);
435 if ((Ret != kEplSuccessful)
436 && (Ret != kEplShutdown)) {
437 EventSource = kEplEventSourceErrk;
438
439 // Error event for API layer
440 EplEventkPostError
441 (kEplEventSourceEventk, Ret,
442 sizeof(EventSource), &EventSource);
443 }
444 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
445 // forward SoA event to PDO module
446 pEvent_p->m_EventType = kEplEventTypePdoSoa;
447 Ret = EplPdokProcess(pEvent_p);
448 if ((Ret != kEplSuccessful)
449 && (Ret != kEplShutdown)) {
450 EventSource = kEplEventSourcePdok;
451
452 // Error event for API layer
453 EplEventkPostError
454 (kEplEventSourceEventk, Ret,
455 sizeof(EventSource), &EventSource);
456 }
457 #endif
458
459 }
460 break;
461 #endif
462 }
463
464 // events for Dllk module
465 case kEplEventSinkDllk:
466 {
467 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
468 Ret = EplDllkProcess(pEvent_p);
469 if ((Ret != kEplSuccessful) && (Ret != kEplShutdown)) {
470 EventSource = kEplEventSourceDllk;
471
472 // Error event for API layer
473 EplEventkPostError(kEplEventSourceEventk,
474 Ret,
475 sizeof(EventSource),
476 &EventSource);
477 }
478 #endif
479 break;
480 }
481
482 // events for DllkCal module
483 case kEplEventSinkDllkCal:
484 {
485 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
486 Ret = EplDllkCalProcess(pEvent_p);
487 if ((Ret != kEplSuccessful) && (Ret != kEplShutdown)) {
488 EventSource = kEplEventSourceDllk;
489
490 // Error event for API layer
491 EplEventkPostError(kEplEventSourceEventk,
492 Ret,
493 sizeof(EventSource),
494 &EventSource);
495 }
496 #endif
497 break;
498 }
499
500 //
501 case kEplEventSinkPdok:
502 {
503 // PDO-Module
504 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
505 Ret = EplPdokProcess(pEvent_p);
506 if ((Ret != kEplSuccessful) && (Ret != kEplShutdown)) {
507 EventSource = kEplEventSourcePdok;
508
509 // Error event for API layer
510 EplEventkPostError(kEplEventSourceEventk,
511 Ret,
512 sizeof(EventSource),
513 &EventSource);
514 }
515 #endif
516 break;
517 }
518
519 // events for Error handler module
520 case kEplEventSinkErrk:
521 {
522 // only call error handler if DLL is present
523 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
524 Ret = EplErrorHandlerkProcess(pEvent_p);
525 if ((Ret != kEplSuccessful) && (Ret != kEplShutdown)) {
526 EventSource = kEplEventSourceErrk;
527
528 // Error event for API layer
529 EplEventkPostError(kEplEventSourceEventk,
530 Ret,
531 sizeof(EventSource),
532 &EventSource);
533 }
534 break;
535 #endif
536 }
537
538 // unknown sink
539 default:
540 {
541 Ret = kEplEventUnknownSink;
542 }
543
544 } // end of switch(pEvent_p->m_EventSink)
545
546 Exit:
547 return Ret;
548
549 }
550
551 //---------------------------------------------------------------------------
552 //
553 // Function: EplEventkPost
554 //
555 // Description: post events from kernel part
556 //
557 // Parameters: pEvent_p = pointer to event-structure from buffer
558 //
559 // Returns: tEpKernel = errorcode
560 //
561 // State:
562 //
563 //---------------------------------------------------------------------------
564
EplEventkPost(tEplEvent * pEvent_p)565 tEplKernel PUBLIC EplEventkPost(tEplEvent * pEvent_p)
566 {
567 tEplKernel Ret;
568 #ifndef EPL_NO_FIFO
569 tShbError ShbError;
570 tShbCirChunk ShbCirChunk;
571 unsigned long ulDataSize;
572 unsigned int fBufferCompleted;
573 #endif
574
575 Ret = kEplSuccessful;
576
577 // the event must be posted by using the abBuffer
578 // it is neede because the Argument must by copied
579 // to the buffer too and not only the pointer
580
581 #ifndef EPL_NO_FIFO
582 // 2006/08/03 d.k.: Event and argument are posted as separate chunks to the event queue.
583 ulDataSize =
584 sizeof(tEplEvent) +
585 ((pEvent_p->m_pArg != NULL) ? pEvent_p->m_uiSize : 0);
586 #endif
587
588 // decide in which buffer the event have to write
589 switch (pEvent_p->m_EventSink) {
590 // kernelspace modules
591 case kEplEventSinkSync:
592 case kEplEventSinkNmtk:
593 case kEplEventSinkDllk:
594 case kEplEventSinkDllkCal:
595 case kEplEventSinkPdok:
596 case kEplEventSinkErrk:
597 {
598 #ifndef EPL_NO_FIFO
599 // post message
600 BENCHMARK_MOD_27_SET(2);
601 ShbError =
602 ShbCirAllocDataBlock(EplEventkInstance_g.
603 m_pShbUserToKernelInstance,
604 &ShbCirChunk, ulDataSize);
605 switch (ShbError) {
606 case kShbOk:
607 break;
608
609 case kShbBufferFull:
610 {
611 EplEventkInstance_g.
612 m_uiUserToKernelFullCount++;
613 Ret = kEplEventPostError;
614 goto Exit;
615 }
616
617 default:
618 {
619 EPL_DBGLVL_EVENTK_TRACE1
620 ("EplEventkPost(): ShbCirAllocDataBlock(U2K) -> 0x%X\n",
621 ShbError);
622 Ret = kEplEventPostError;
623 goto Exit;
624 }
625 }
626 ShbError =
627 ShbCirWriteDataChunk(EplEventkInstance_g.
628 m_pShbUserToKernelInstance,
629 &ShbCirChunk, pEvent_p,
630 sizeof(tEplEvent),
631 &fBufferCompleted);
632 if (ShbError != kShbOk) {
633 EPL_DBGLVL_EVENTK_TRACE1
634 ("EplEventkPost(): ShbCirWriteDataChunk(U2K) -> 0x%X\n",
635 ShbError);
636 Ret = kEplEventPostError;
637 goto Exit;
638 }
639 if (fBufferCompleted == FALSE) {
640 ShbError =
641 ShbCirWriteDataChunk(EplEventkInstance_g.
642 m_pShbUserToKernelInstance,
643 &ShbCirChunk,
644 pEvent_p->m_pArg,
645 (unsigned long)
646 pEvent_p->m_uiSize,
647 &fBufferCompleted);
648 if ((ShbError != kShbOk)
649 || (fBufferCompleted == FALSE)) {
650 EPL_DBGLVL_EVENTK_TRACE1
651 ("EplEventkPost(): ShbCirWriteDataChunk2(U2K) -> 0x%X\n",
652 ShbError);
653 Ret = kEplEventPostError;
654 goto Exit;
655 }
656 }
657 BENCHMARK_MOD_27_RESET(2);
658
659 #else
660 Ret = EplEventkProcess(pEvent_p);
661 #endif
662
663 break;
664 }
665
666 // userspace modules
667 case kEplEventSinkNmtu:
668 case kEplEventSinkNmtMnu:
669 case kEplEventSinkSdoAsySeq:
670 case kEplEventSinkApi:
671 case kEplEventSinkDlluCal:
672 case kEplEventSinkErru:
673 {
674 #ifndef EPL_NO_FIFO
675 // post message
676 // BENCHMARK_MOD_27_SET(3); // 74 �s until reset
677 ShbError =
678 ShbCirAllocDataBlock(EplEventkInstance_g.
679 m_pShbKernelToUserInstance,
680 &ShbCirChunk, ulDataSize);
681 if (ShbError != kShbOk) {
682 EPL_DBGLVL_EVENTK_TRACE1
683 ("EplEventkPost(): ShbCirAllocDataBlock(K2U) -> 0x%X\n",
684 ShbError);
685 Ret = kEplEventPostError;
686 goto Exit;
687 }
688 ShbError =
689 ShbCirWriteDataChunk(EplEventkInstance_g.
690 m_pShbKernelToUserInstance,
691 &ShbCirChunk, pEvent_p,
692 sizeof(tEplEvent),
693 &fBufferCompleted);
694 if (ShbError != kShbOk) {
695 EPL_DBGLVL_EVENTK_TRACE1
696 ("EplEventkPost(): ShbCirWriteDataChunk(K2U) -> 0x%X\n",
697 ShbError);
698 Ret = kEplEventPostError;
699 goto Exit;
700 }
701 if (fBufferCompleted == FALSE) {
702 ShbError =
703 ShbCirWriteDataChunk(EplEventkInstance_g.
704 m_pShbKernelToUserInstance,
705 &ShbCirChunk,
706 pEvent_p->m_pArg,
707 (unsigned long)
708 pEvent_p->m_uiSize,
709 &fBufferCompleted);
710 if ((ShbError != kShbOk)
711 || (fBufferCompleted == FALSE)) {
712 EPL_DBGLVL_EVENTK_TRACE1
713 ("EplEventkPost(): ShbCirWriteDataChunk2(K2U) -> 0x%X\n",
714 ShbError);
715 Ret = kEplEventPostError;
716 goto Exit;
717 }
718 }
719 // BENCHMARK_MOD_27_RESET(3); // 82 �s until ShbCirGetReadDataSize() in EplEventu
720
721 #else
722 Ret = EplEventuProcess(pEvent_p);
723 #endif
724
725 break;
726 }
727
728 default:
729 {
730 Ret = kEplEventUnknownSink;
731 }
732
733 } // end of switch(pEvent_p->m_EventSink)
734
735 #ifndef EPL_NO_FIFO
736 Exit:
737 #endif
738 return Ret;
739 }
740
741 //---------------------------------------------------------------------------
742 //
743 // Function: EplEventkPostError
744 //
745 // Description: post error event from kernel part to API layer
746 //
747 // Parameters: EventSource_p = source-module of the error event
748 // EplError_p = code of occured error
749 // ArgSize_p = size of the argument
750 // pArg_p = pointer to the argument
751 //
752 // Returns: tEpKernel = errorcode
753 //
754 // State:
755 //
756 //---------------------------------------------------------------------------
757
EplEventkPostError(tEplEventSource EventSource_p,tEplKernel EplError_p,unsigned int uiArgSize_p,void * pArg_p)758 tEplKernel PUBLIC EplEventkPostError(tEplEventSource EventSource_p,
759 tEplKernel EplError_p,
760 unsigned int uiArgSize_p, void *pArg_p)
761 {
762 tEplKernel Ret;
763 BYTE abBuffer[EPL_MAX_EVENT_ARG_SIZE];
764 tEplEventError *pEventError = (tEplEventError *) abBuffer;
765 tEplEvent EplEvent;
766
767 Ret = kEplSuccessful;
768
769 // create argument
770 pEventError->m_EventSource = EventSource_p;
771 pEventError->m_EplError = EplError_p;
772 EPL_MEMCPY(&pEventError->m_Arg, pArg_p, uiArgSize_p);
773
774 // create event
775 EplEvent.m_EventType = kEplEventTypeError;
776 EplEvent.m_EventSink = kEplEventSinkApi;
777 EPL_MEMSET(&EplEvent.m_NetTime, 0x00, sizeof(EplEvent.m_NetTime));
778 EplEvent.m_uiSize =
779 (sizeof(EventSource_p) + sizeof(EplError_p) + uiArgSize_p);
780 EplEvent.m_pArg = &abBuffer[0];
781
782 // post errorevent
783 Ret = EplEventkPost(&EplEvent);
784
785 return Ret;
786 }
787
788 //=========================================================================//
789 // //
790 // P R I V A T E F U N C T I O N S //
791 // //
792 //=========================================================================//
793
794 //---------------------------------------------------------------------------
795 //
796 // Function: EplEventkRxSignalHandlerCb()
797 //
798 // Description: Callback-function for events from user and kernel part
799 //
800 // Parameters: pShbRxInstance_p = Instance-pointer of buffer
801 // ulDataSize_p = size of data
802 //
803 // Returns: void
804 //
805 // State:
806 //
807 //---------------------------------------------------------------------------
808
809 #ifndef EPL_NO_FIFO
EplEventkRxSignalHandlerCb(tShbInstance pShbRxInstance_p,unsigned long ulDataSize_p)810 static void EplEventkRxSignalHandlerCb(tShbInstance pShbRxInstance_p,
811 unsigned long ulDataSize_p)
812 {
813 tEplEvent *pEplEvent;
814 tShbError ShbError;
815 //unsigned long ulBlockCount;
816 //unsigned long ulDataSize;
817 BYTE abDataBuffer[sizeof(tEplEvent) + EPL_MAX_EVENT_ARG_SIZE];
818 // d.k.: abDataBuffer contains the complete tEplEvent structure
819 // and behind this the argument
820
821 TGT_DBG_SIGNAL_TRACE_POINT(20);
822
823 BENCHMARK_MOD_27_RESET(0);
824 // copy data from event queue
825 ShbError = ShbCirReadDataBlock(pShbRxInstance_p,
826 &abDataBuffer[0],
827 sizeof(abDataBuffer), &ulDataSize_p);
828 if (ShbError != kShbOk) {
829 // error goto exit
830 goto Exit;
831 }
832 // resolve the pointer to the event structure
833 pEplEvent = (tEplEvent *) abDataBuffer;
834 // set Datasize
835 pEplEvent->m_uiSize = (ulDataSize_p - sizeof(tEplEvent));
836 if (pEplEvent->m_uiSize > 0) {
837 // set pointer to argument
838 pEplEvent->m_pArg = &abDataBuffer[sizeof(tEplEvent)];
839 } else {
840 //set pointer to NULL
841 pEplEvent->m_pArg = NULL;
842 }
843
844 BENCHMARK_MOD_27_SET(0);
845 // call processfunction
846 EplEventkProcess(pEplEvent);
847
848 Exit:
849 return;
850 }
851 #endif
852
853 // EOF
854