Merge branch 'linus' into release
[linux-2.6] / drivers / staging / epl / EplEventu.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 Epl-Userspace-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: EplEventu.c,v $
53
54                 $Author: D.Krueger $
55
56                 $Revision: 1.8 $  $Date: 2008/11/17 16:40:39 $
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 "user/EplEventu.h"
72 #include "user/EplNmtu.h"
73 #include "user/EplNmtMnu.h"
74 #include "user/EplSdoAsySequ.h"
75 #include "user/EplDlluCal.h"
76 #include "user/EplLedu.h"
77 #include "Benchmark.h"
78
79 #ifdef EPL_NO_FIFO
80 #include "kernel/EplEventk.h"
81 #else
82 #include "SharedBuff.h"
83 #endif
84
85 /***************************************************************************/
86 /*                                                                         */
87 /*                                                                         */
88 /*          G L O B A L   D E F I N I T I O N S                            */
89 /*                                                                         */
90 /*                                                                         */
91 /***************************************************************************/
92
93 //---------------------------------------------------------------------------
94 // const defines
95 //---------------------------------------------------------------------------
96
97 // TracePoint support for realtime-debugging
98 #ifdef _DBG_TRACE_POINTS_
99 void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
100 void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p);
101 #define TGT_DBG_SIGNAL_TRACE_POINT(p)   TgtDbgSignalTracePoint(p)
102 #define TGT_DBG_POST_TRACE_VALUE(v)     TgtDbgPostTraceValue(v)
103 #else
104 #define TGT_DBG_SIGNAL_TRACE_POINT(p)
105 #define TGT_DBG_POST_TRACE_VALUE(v)
106 #endif
107
108 //---------------------------------------------------------------------------
109 // local types
110 //---------------------------------------------------------------------------
111
112 typedef struct {
113 #ifndef EPL_NO_FIFO
114         tShbInstance m_pShbKernelToUserInstance;
115         tShbInstance m_pShbUserToKernelInstance;
116 #endif
117         tEplProcessEventCb m_pfnApiProcessEventCb;
118
119 } tEplEventuInstance;
120
121 //---------------------------------------------------------------------------
122 // modul globale vars
123 //---------------------------------------------------------------------------
124
125 //#ifndef EPL_NO_FIFO
126 static tEplEventuInstance EplEventuInstance_g;
127 //#endif
128
129 //---------------------------------------------------------------------------
130 // local function prototypes
131 //---------------------------------------------------------------------------
132
133 #ifndef EPL_NO_FIFO
134 // callback function for incomming events
135 static void EplEventuRxSignalHandlerCb(tShbInstance pShbRxInstance_p,
136                                        unsigned long ulDataSize_p);
137 #endif
138
139 /***************************************************************************/
140 /*                                                                         */
141 /*                                                                         */
142 /*          C L A S S  <Epl-User-Event>                                    */
143 /*                                                                         */
144 /*                                                                         */
145 /***************************************************************************/
146 //
147 // Description:
148 //
149 //
150 /***************************************************************************/
151
152 //=========================================================================//
153 //                                                                         //
154 //          P U B L I C   F U N C T I O N S                                //
155 //                                                                         //
156 //=========================================================================//
157
158 //---------------------------------------------------------------------------
159 //
160 // Function:    EplEventuInit
161 //
162 // Description: function initialize the first instance
163 //
164 //
165 //
166 // Parameters:  pfnApiProcessEventCb_p  = function pointer for API event callback
167 //
168 //
169 // Returns:      tEpKernel  = errorcode
170 //
171 //
172 // State:
173 //
174 //---------------------------------------------------------------------------
175 tEplKernel PUBLIC EplEventuInit(tEplProcessEventCb pfnApiProcessEventCb_p)
176 {
177         tEplKernel Ret;
178
179         Ret = EplEventuAddInstance(pfnApiProcessEventCb_p);
180
181         return Ret;
182
183 }
184
185 //---------------------------------------------------------------------------
186 //
187 // Function:    EplEventuAddInstance
188 //
189 // Description: function add one more instance
190 //
191 //
192 //
193 // Parameters:  pfnApiProcessEventCb_p  = function pointer for API event callback
194 //
195 //
196 // Returns:      tEpKernel  = errorcode
197 //
198 //
199 // State:
200 //
201 //---------------------------------------------------------------------------
202 tEplKernel PUBLIC EplEventuAddInstance(tEplProcessEventCb
203                                        pfnApiProcessEventCb_p)
204 {
205         tEplKernel Ret;
206 #ifndef EPL_NO_FIFO
207         tShbError ShbError;
208         unsigned int fShbNewCreated;
209 #endif
210
211         Ret = kEplSuccessful;
212
213         // init instance variables
214         EplEventuInstance_g.m_pfnApiProcessEventCb = pfnApiProcessEventCb_p;
215
216 #ifndef EPL_NO_FIFO
217         // init shared loop buffer
218         // kernel -> user
219         ShbError = ShbCirAllocBuffer(EPL_EVENT_SIZE_SHB_KERNEL_TO_USER,
220                                      EPL_EVENT_NAME_SHB_KERNEL_TO_USER,
221                                      &EplEventuInstance_g.
222                                      m_pShbKernelToUserInstance,
223                                      &fShbNewCreated);
224         if (ShbError != kShbOk) {
225                 EPL_DBGLVL_EVENTK_TRACE1
226                     ("EplEventuAddInstance(): ShbCirAllocBuffer(K2U) -> 0x%X\n",
227                      ShbError);
228                 Ret = kEplNoResource;
229                 goto Exit;
230         }
231
232         // user -> kernel
233         ShbError = ShbCirAllocBuffer(EPL_EVENT_SIZE_SHB_USER_TO_KERNEL,
234                                      EPL_EVENT_NAME_SHB_USER_TO_KERNEL,
235                                      &EplEventuInstance_g.
236                                      m_pShbUserToKernelInstance,
237                                      &fShbNewCreated);
238         if (ShbError != kShbOk) {
239                 EPL_DBGLVL_EVENTK_TRACE1
240                     ("EplEventuAddInstance(): ShbCirAllocBuffer(U2K) -> 0x%X\n",
241                      ShbError);
242                 Ret = kEplNoResource;
243                 goto Exit;
244         }
245         // register eventhandler
246         ShbError =
247             ShbCirSetSignalHandlerNewData(EplEventuInstance_g.
248                                           m_pShbKernelToUserInstance,
249                                           EplEventuRxSignalHandlerCb,
250                                           kShbPriorityNormal);
251         if (ShbError != kShbOk) {
252                 EPL_DBGLVL_EVENTK_TRACE1
253                     ("EplEventuAddInstance(): ShbCirSetSignalHandlerNewData(K2U) -> 0x%X\n",
254                      ShbError);
255                 Ret = kEplNoResource;
256                 goto Exit;
257         }
258
259       Exit:
260 #endif
261
262         return Ret;
263
264 }
265
266 //---------------------------------------------------------------------------
267 //
268 // Function:    EplEventuDelInstance
269 //
270 // Description: function delete instance an free the bufferstructure
271 //
272 //
273 //
274 // Parameters:
275 //
276 //
277 // Returns:      tEpKernel  = errorcode
278 //
279 //
280 // State:
281 //
282 //---------------------------------------------------------------------------
283 tEplKernel PUBLIC EplEventuDelInstance()
284 {
285         tEplKernel Ret;
286 #ifndef EPL_NO_FIFO
287         tShbError ShbError;
288 #endif
289
290         Ret = kEplSuccessful;
291
292 #ifndef EPL_NO_FIFO
293         // set eventhandler to NULL
294         ShbError =
295             ShbCirSetSignalHandlerNewData(EplEventuInstance_g.
296                                           m_pShbKernelToUserInstance, NULL,
297                                           kShbPriorityNormal);
298         if (ShbError != kShbOk) {
299                 EPL_DBGLVL_EVENTK_TRACE1
300                     ("EplEventuDelInstance(): ShbCirSetSignalHandlerNewData(K2U) -> 0x%X\n",
301                      ShbError);
302                 Ret = kEplNoResource;
303         }
304         // free buffer User -> Kernel
305         ShbError =
306             ShbCirReleaseBuffer(EplEventuInstance_g.m_pShbUserToKernelInstance);
307         if ((ShbError != kShbOk) && (ShbError != kShbMemUsedByOtherProcs)) {
308                 EPL_DBGLVL_EVENTK_TRACE1
309                     ("EplEventuDelInstance(): ShbCirReleaseBuffer(U2K) -> 0x%X\n",
310                      ShbError);
311                 Ret = kEplNoResource;
312         } else {
313                 EplEventuInstance_g.m_pShbUserToKernelInstance = NULL;
314         }
315
316         // free buffer  Kernel -> User
317         ShbError =
318             ShbCirReleaseBuffer(EplEventuInstance_g.m_pShbKernelToUserInstance);
319         if ((ShbError != kShbOk) && (ShbError != kShbMemUsedByOtherProcs)) {
320                 EPL_DBGLVL_EVENTK_TRACE1
321                     ("EplEventuDelInstance(): ShbCirReleaseBuffer(K2U) -> 0x%X\n",
322                      ShbError);
323                 Ret = kEplNoResource;
324         } else {
325                 EplEventuInstance_g.m_pShbKernelToUserInstance = NULL;
326         }
327
328 #endif
329
330         return Ret;
331
332 }
333
334 //---------------------------------------------------------------------------
335 //
336 // Function:    EplEventuProcess
337 //
338 // Description: Kernelthread that dispatches events in kernelspace
339 //
340 //
341 //
342 // Parameters:  pEvent_p = pointer to event-structur from buffer
343 //
344 //
345 // Returns:      tEpKernel  = errorcode
346 //
347 //
348 // State:
349 //
350 //---------------------------------------------------------------------------
351 tEplKernel PUBLIC EplEventuProcess(tEplEvent * pEvent_p)
352 {
353         tEplKernel Ret;
354         tEplEventSource EventSource;
355
356         Ret = kEplSuccessful;
357
358         // check m_EventSink
359         switch (pEvent_p->m_EventSink) {
360                 // NMT-User-Module
361         case kEplEventSinkNmtu:
362                 {
363 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0)
364                         Ret = EplNmtuProcessEvent(pEvent_p);
365                         if ((Ret != kEplSuccessful) && (Ret != kEplShutdown)) {
366                                 EventSource = kEplEventSourceNmtu;
367
368                                 // Error event for API layer
369                                 EplEventuPostError(kEplEventSourceEventu,
370                                                    Ret,
371                                                    sizeof(EventSource),
372                                                    &EventSource);
373                         }
374 #endif
375                         break;
376                 }
377
378 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
379                 // NMT-MN-User-Module
380         case kEplEventSinkNmtMnu:
381                 {
382                         Ret = EplNmtMnuProcessEvent(pEvent_p);
383                         if ((Ret != kEplSuccessful) && (Ret != kEplShutdown)) {
384                                 EventSource = kEplEventSourceNmtMnu;
385
386                                 // Error event for API layer
387                                 EplEventuPostError(kEplEventSourceEventu,
388                                                    Ret,
389                                                    sizeof(EventSource),
390                                                    &EventSource);
391                         }
392                         break;
393                 }
394 #endif
395
396 #if ((((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)   \
397      || (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOS)) != 0))
398                 // events for asynchronus SDO Sequence Layer
399         case kEplEventSinkSdoAsySeq:
400                 {
401                         Ret = EplSdoAsySeqProcessEvent(pEvent_p);
402                         if ((Ret != kEplSuccessful) && (Ret != kEplShutdown)) {
403                                 EventSource = kEplEventSourceSdoAsySeq;
404
405                                 // Error event for API layer
406                                 EplEventuPostError(kEplEventSourceEventu,
407                                                    Ret,
408                                                    sizeof(EventSource),
409                                                    &EventSource);
410                         }
411                         break;
412                 }
413 #endif
414
415                 // LED user part module
416         case kEplEventSinkLedu:
417                 {
418 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0)
419                         Ret = EplLeduProcessEvent(pEvent_p);
420                         if ((Ret != kEplSuccessful) && (Ret != kEplShutdown)) {
421                                 EventSource = kEplEventSourceLedu;
422
423                                 // Error event for API layer
424                                 EplEventuPostError(kEplEventSourceEventu,
425                                                    Ret,
426                                                    sizeof(EventSource),
427                                                    &EventSource);
428                         }
429 #endif
430                         break;
431                 }
432
433                 // event for EPL api
434         case kEplEventSinkApi:
435                 {
436                         if (EplEventuInstance_g.m_pfnApiProcessEventCb != NULL) {
437                                 Ret =
438                                     EplEventuInstance_g.
439                                     m_pfnApiProcessEventCb(pEvent_p);
440                                 if ((Ret != kEplSuccessful)
441                                     && (Ret != kEplShutdown)) {
442                                         EventSource = kEplEventSourceEplApi;
443
444                                         // Error event for API layer
445                                         EplEventuPostError
446                                             (kEplEventSourceEventu, Ret,
447                                              sizeof(EventSource), &EventSource);
448                                 }
449                         }
450                         break;
451
452                 }
453
454         case kEplEventSinkDlluCal:
455                 {
456                         Ret = EplDlluCalProcess(pEvent_p);
457                         if ((Ret != kEplSuccessful) && (Ret != kEplShutdown)) {
458                                 EventSource = kEplEventSourceDllu;
459
460                                 // Error event for API layer
461                                 EplEventuPostError(kEplEventSourceEventu,
462                                                    Ret,
463                                                    sizeof(EventSource),
464                                                    &EventSource);
465                         }
466                         break;
467
468                 }
469
470         case kEplEventSinkErru:
471                 {
472                         /*
473                            Ret = EplErruProcess(pEvent_p);
474                            if ((Ret != kEplSuccessful) && (Ret != kEplShutdown))
475                            {
476                            EventSource = kEplEventSourceErru;
477
478                            // Error event for API layer
479                            EplEventuPostError(kEplEventSourceEventu,
480                            Ret,
481                            sizeof(EventSource),
482                            &EventSource);
483                            }
484                          */
485                         break;
486
487                 }
488
489                 // unknown sink
490         default:
491                 {
492                         Ret = kEplEventUnknownSink;
493                 }
494
495         }                       // end of switch(pEvent_p->m_EventSink)
496
497         return Ret;
498
499 }
500
501 //---------------------------------------------------------------------------
502 //
503 // Function:    EplEventuPost
504 //
505 // Description: post events from userspace
506 //
507 //
508 //
509 // Parameters:  pEvent_p = pointer to event-structur from buffer
510 //
511 //
512 // Returns:      tEpKernel  = errorcode
513 //
514 //
515 // State:
516 //
517 //---------------------------------------------------------------------------
518 tEplKernel PUBLIC EplEventuPost(tEplEvent * pEvent_p)
519 {
520         tEplKernel Ret;
521 #ifndef EPL_NO_FIFO
522         tShbError ShbError;
523         tShbCirChunk ShbCirChunk;
524         unsigned long ulDataSize;
525         unsigned int fBufferCompleted;
526 #endif
527
528         Ret = kEplSuccessful;
529
530 #ifndef EPL_NO_FIFO
531         // 2006/08/03 d.k.: Event and argument are posted as separate chunks to the event queue.
532         ulDataSize =
533             sizeof(tEplEvent) +
534             ((pEvent_p->m_pArg != NULL) ? pEvent_p->m_uiSize : 0);
535 #endif
536
537         // decide in which buffer the event have to write
538         switch (pEvent_p->m_EventSink) {
539                 // kernelspace modules
540         case kEplEventSinkSync:
541         case kEplEventSinkNmtk:
542         case kEplEventSinkDllk:
543         case kEplEventSinkDllkCal:
544         case kEplEventSinkPdok:
545         case kEplEventSinkErrk:
546                 {
547 #ifndef EPL_NO_FIFO
548                         // post message
549                         ShbError =
550                             ShbCirAllocDataBlock(EplEventuInstance_g.
551                                                  m_pShbUserToKernelInstance,
552                                                  &ShbCirChunk, ulDataSize);
553                         if (ShbError != kShbOk) {
554                                 EPL_DBGLVL_EVENTK_TRACE1
555                                     ("EplEventuPost(): ShbCirAllocDataBlock(U2K) -> 0x%X\n",
556                                      ShbError);
557                                 Ret = kEplEventPostError;
558                                 goto Exit;
559                         }
560                         ShbError =
561                             ShbCirWriteDataChunk(EplEventuInstance_g.
562                                                  m_pShbUserToKernelInstance,
563                                                  &ShbCirChunk, pEvent_p,
564                                                  sizeof(tEplEvent),
565                                                  &fBufferCompleted);
566                         if (ShbError != kShbOk) {
567                                 EPL_DBGLVL_EVENTK_TRACE1
568                                     ("EplEventuPost(): ShbCirWriteDataChunk(U2K) -> 0x%X\n",
569                                      ShbError);
570                                 Ret = kEplEventPostError;
571                                 goto Exit;
572                         }
573                         if (fBufferCompleted == FALSE) {
574                                 ShbError =
575                                     ShbCirWriteDataChunk(EplEventuInstance_g.
576                                                          m_pShbUserToKernelInstance,
577                                                          &ShbCirChunk,
578                                                          pEvent_p->m_pArg,
579                                                          (unsigned long)
580                                                          pEvent_p->m_uiSize,
581                                                          &fBufferCompleted);
582                                 if ((ShbError != kShbOk)
583                                     || (fBufferCompleted == FALSE)) {
584                                         EPL_DBGLVL_EVENTK_TRACE1
585                                             ("EplEventuPost(): ShbCirWriteDataChunk2(U2K) -> 0x%X\n",
586                                              ShbError);
587                                         Ret = kEplEventPostError;
588                                         goto Exit;
589                                 }
590                         }
591 #else
592                         Ret = EplEventkProcess(pEvent_p);
593 #endif
594
595                         break;
596                 }
597
598                 // userspace modules
599         case kEplEventSinkNmtMnu:
600         case kEplEventSinkNmtu:
601         case kEplEventSinkSdoAsySeq:
602         case kEplEventSinkApi:
603         case kEplEventSinkDlluCal:
604         case kEplEventSinkErru:
605         case kEplEventSinkLedu:
606                 {
607 #ifndef EPL_NO_FIFO
608                         // post message
609                         ShbError =
610                             ShbCirAllocDataBlock(EplEventuInstance_g.
611                                                  m_pShbKernelToUserInstance,
612                                                  &ShbCirChunk, ulDataSize);
613                         if (ShbError != kShbOk) {
614                                 EPL_DBGLVL_EVENTK_TRACE1
615                                     ("EplEventuPost(): ShbCirAllocDataBlock(K2U) -> 0x%X\n",
616                                      ShbError);
617                                 Ret = kEplEventPostError;
618                                 goto Exit;
619                         }
620                         ShbError =
621                             ShbCirWriteDataChunk(EplEventuInstance_g.
622                                                  m_pShbKernelToUserInstance,
623                                                  &ShbCirChunk, pEvent_p,
624                                                  sizeof(tEplEvent),
625                                                  &fBufferCompleted);
626                         if (ShbError != kShbOk) {
627                                 EPL_DBGLVL_EVENTK_TRACE1
628                                     ("EplEventuPost(): ShbCirWriteDataChunk(K2U) -> 0x%X\n",
629                                      ShbError);
630                                 Ret = kEplEventPostError;
631                                 goto Exit;
632                         }
633                         if (fBufferCompleted == FALSE) {
634                                 ShbError =
635                                     ShbCirWriteDataChunk(EplEventuInstance_g.
636                                                          m_pShbKernelToUserInstance,
637                                                          &ShbCirChunk,
638                                                          pEvent_p->m_pArg,
639                                                          (unsigned long)
640                                                          pEvent_p->m_uiSize,
641                                                          &fBufferCompleted);
642                                 if ((ShbError != kShbOk)
643                                     || (fBufferCompleted == FALSE)) {
644                                         EPL_DBGLVL_EVENTK_TRACE1
645                                             ("EplEventuPost(): ShbCirWriteDataChunk2(K2U) -> 0x%X\n",
646                                              ShbError);
647                                         Ret = kEplEventPostError;
648                                         goto Exit;
649                                 }
650                         }
651 #else
652                         Ret = EplEventuProcess(pEvent_p);
653 #endif
654
655                         break;
656                 }
657
658         default:
659                 {
660                         Ret = kEplEventUnknownSink;
661                 }
662
663         }                       // end of switch(pEvent_p->m_EventSink)
664
665 #ifndef EPL_NO_FIFO
666       Exit:
667 #endif
668         return Ret;
669
670 }
671
672 //---------------------------------------------------------------------------
673 //
674 // Function:    EplEventuPostError
675 //
676 // Description: post errorevent from userspace
677 //
678 //
679 //
680 // Parameters:  EventSource_p   = source-module of the errorevent
681 //              EplError_p     = code of occured error
682 //              uiArgSize_p     = size of the argument
683 //              pArg_p          = pointer to the argument
684 //
685 //
686 // Returns:      tEpKernel  = errorcode
687 //
688 //
689 // State:
690 //
691 //---------------------------------------------------------------------------
692 tEplKernel PUBLIC EplEventuPostError(tEplEventSource EventSource_p,
693                                      tEplKernel EplError_p,
694                                      unsigned int uiArgSize_p, void *pArg_p)
695 {
696         tEplKernel Ret;
697         BYTE abBuffer[EPL_MAX_EVENT_ARG_SIZE];
698         tEplEventError *pEventError = (tEplEventError *) abBuffer;
699         tEplEvent EplEvent;
700
701         Ret = kEplSuccessful;
702
703         // create argument
704         pEventError->m_EventSource = EventSource_p;
705         pEventError->m_EplError = EplError_p;
706         EPL_MEMCPY(&pEventError->m_Arg, pArg_p, uiArgSize_p);
707
708         // create event
709         EplEvent.m_EventType = kEplEventTypeError;
710         EplEvent.m_EventSink = kEplEventSinkApi;
711         EPL_MEMSET(&EplEvent.m_NetTime, 0x00, sizeof(EplEvent.m_NetTime));
712         EplEvent.m_uiSize =
713             (sizeof(EventSource_p) + sizeof(EplError_p) + uiArgSize_p);
714         EplEvent.m_pArg = &abBuffer[0];
715
716         // post errorevent
717         Ret = EplEventuPost(&EplEvent);
718
719         return Ret;
720 }
721
722 //=========================================================================//
723 //                                                                         //
724 //          P R I V A T E   F U N C T I O N S                              //
725 //                                                                         //
726 //=========================================================================//
727
728 //---------------------------------------------------------------------------
729 //
730 // Function:    EplEventuRxSignalHandlerCb()
731 //
732 // Description: Callback-function for evets from kernelspace
733 //
734 //
735 //
736 // Parameters:  pShbRxInstance_p    = Instance-pointer for buffer
737 //              ulDataSize_p        = size of data
738 //
739 //
740 // Returns: void
741 //
742 //
743 // State:
744 //
745 //---------------------------------------------------------------------------
746 #ifndef EPL_NO_FIFO
747 static void EplEventuRxSignalHandlerCb(tShbInstance pShbRxInstance_p,
748                                        unsigned long ulDataSize_p)
749 {
750         tEplEvent *pEplEvent;
751         tShbError ShbError;
752 //unsigned long   ulBlockCount;
753 //unsigned long   ulDataSize;
754         BYTE abDataBuffer[sizeof(tEplEvent) + EPL_MAX_EVENT_ARG_SIZE];
755         // d.k.: abDataBuffer contains the complete tEplEvent structure
756         //       and behind this the argument
757
758         TGT_DBG_SIGNAL_TRACE_POINT(21);
759
760 // d.k. not needed because it is already done in SharedBuff
761 /*    do
762     {
763         BENCHMARK_MOD_28_SET(1);    // 4 µs until reset
764         // get messagesize
765         ShbError = ShbCirGetReadDataSize (pShbRxInstance_p, &ulDataSize);
766         if(ShbError != kShbOk)
767         {
768             // error goto exit
769             goto Exit;
770         }
771
772         BENCHMARK_MOD_28_RESET(1);  // 14 µs until set
773 */
774         // copy data from event queue
775         ShbError = ShbCirReadDataBlock(pShbRxInstance_p,
776                                        &abDataBuffer[0],
777                                        sizeof(abDataBuffer), &ulDataSize_p);
778         if (ShbError != kShbOk) {
779                 // error goto exit
780                 goto Exit;
781         }
782         // resolve the pointer to the event structure
783         pEplEvent = (tEplEvent *) abDataBuffer;
784         // set Datasize
785         pEplEvent->m_uiSize = (ulDataSize_p - sizeof(tEplEvent));
786         if (pEplEvent->m_uiSize > 0) {
787                 // set pointer to argument
788                 pEplEvent->m_pArg = &abDataBuffer[sizeof(tEplEvent)];
789         } else {
790                 //set pointer to NULL
791                 pEplEvent->m_pArg = NULL;
792         }
793
794         BENCHMARK_MOD_28_SET(1);
795         // call processfunction
796         EplEventuProcess(pEplEvent);
797
798         BENCHMARK_MOD_28_RESET(1);
799         // read number of left messages to process
800 // d.k. not needed because it is already done in SharedBuff
801 /*        ShbError = ShbCirGetReadBlockCount (pShbRxInstance_p, &ulBlockCount);
802         if (ShbError != kShbOk)
803         {
804             // error goto exit
805             goto Exit;
806         }
807     } while (ulBlockCount > 0);
808 */
809       Exit:
810         return;
811 }
812 #endif
813
814 // EOF