833dfbe746
It's a start, still a mess... Cc: Daniel Krueger <daniel.krueger@systec-electronic.com> Cc: Ronald Sieber <Ronald.Sieber@systec-electronic.com> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
854 lines
24 KiB
C
854 lines
24 KiB
C
/****************************************************************************
|
||
|
||
(c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29
|
||
www.systec-electronic.com
|
||
|
||
Project: openPOWERLINK
|
||
|
||
Description: source file for Epl-Kernelspace-Event-Modul
|
||
|
||
License:
|
||
|
||
Redistribution and use in source and binary forms, with or without
|
||
modification, are permitted provided that the following conditions
|
||
are met:
|
||
|
||
1. Redistributions of source code must retain the above copyright
|
||
notice, this list of conditions and the following disclaimer.
|
||
|
||
2. Redistributions in binary form must reproduce the above copyright
|
||
notice, this list of conditions and the following disclaimer in the
|
||
documentation and/or other materials provided with the distribution.
|
||
|
||
3. Neither the name of SYSTEC electronic GmbH nor the names of its
|
||
contributors may be used to endorse or promote products derived
|
||
from this software without prior written permission. For written
|
||
permission, please contact info@systec-electronic.com.
|
||
|
||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||
COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||
POSSIBILITY OF SUCH DAMAGE.
|
||
|
||
Severability Clause:
|
||
|
||
If a provision of this License is or becomes illegal, invalid or
|
||
unenforceable in any jurisdiction, that shall not affect:
|
||
1. the validity or enforceability in that jurisdiction of any other
|
||
provision of this License; or
|
||
2. the validity or enforceability in other jurisdictions of that or
|
||
any other provision of this License.
|
||
|
||
-------------------------------------------------------------------------
|
||
|
||
$RCSfile: EplEventk.c,v $
|
||
|
||
$Author: D.Krueger $
|
||
|
||
$Revision: 1.9 $ $Date: 2008/10/17 15:32:32 $
|
||
|
||
$State: Exp $
|
||
|
||
Build Environment:
|
||
GCC V3.4
|
||
|
||
-------------------------------------------------------------------------
|
||
|
||
Revision History:
|
||
|
||
2006/06/20 k.t.: start of the implementation
|
||
|
||
****************************************************************************/
|
||
|
||
#include "kernel/EplEventk.h"
|
||
#include "kernel/EplNmtk.h"
|
||
#include "kernel/EplDllk.h"
|
||
#include "kernel/EplDllkCal.h"
|
||
#include "kernel/EplErrorHandlerk.h"
|
||
#include "Benchmark.h"
|
||
|
||
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
|
||
#include "kernel/EplPdok.h"
|
||
#include "kernel/EplPdokCal.h"
|
||
#endif
|
||
|
||
#ifdef EPL_NO_FIFO
|
||
#include "user/EplEventu.h"
|
||
#else
|
||
#include "SharedBuff.h"
|
||
#endif
|
||
|
||
/***************************************************************************/
|
||
/* */
|
||
/* */
|
||
/* G L O B A L D E F I N I T I O N S */
|
||
/* */
|
||
/* */
|
||
/***************************************************************************/
|
||
|
||
//---------------------------------------------------------------------------
|
||
// const defines
|
||
//---------------------------------------------------------------------------
|
||
|
||
// TracePoint support for realtime-debugging
|
||
#ifdef _DBG_TRACE_POINTS_
|
||
void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
|
||
void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p);
|
||
#define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p)
|
||
#define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v)
|
||
#else
|
||
#define TGT_DBG_SIGNAL_TRACE_POINT(p)
|
||
#define TGT_DBG_POST_TRACE_VALUE(v)
|
||
#endif
|
||
|
||
//---------------------------------------------------------------------------
|
||
// local types
|
||
//---------------------------------------------------------------------------
|
||
|
||
typedef struct {
|
||
#ifndef EPL_NO_FIFO
|
||
tShbInstance m_pShbKernelToUserInstance;
|
||
tShbInstance m_pShbUserToKernelInstance;
|
||
#else
|
||
|
||
#endif
|
||
tEplSyncCb m_pfnCbSync;
|
||
unsigned int m_uiUserToKernelFullCount;
|
||
|
||
} tEplEventkInstance;
|
||
|
||
//---------------------------------------------------------------------------
|
||
// modul globale vars
|
||
//---------------------------------------------------------------------------
|
||
static tEplEventkInstance EplEventkInstance_g;
|
||
//---------------------------------------------------------------------------
|
||
// local function prototypes
|
||
//---------------------------------------------------------------------------
|
||
|
||
// callback function for incoming events
|
||
#ifndef EPL_NO_FIFO
|
||
static void EplEventkRxSignalHandlerCb(tShbInstance pShbRxInstance_p,
|
||
unsigned long ulDataSize_p);
|
||
#endif
|
||
|
||
/***************************************************************************/
|
||
/* */
|
||
/* */
|
||
/* C L A S S <Epl-Kernelspace-Event> */
|
||
/* */
|
||
/* */
|
||
/***************************************************************************/
|
||
//
|
||
// Description:
|
||
//
|
||
//
|
||
/***************************************************************************/
|
||
|
||
//=========================================================================//
|
||
// //
|
||
// P U B L I C F U N C T I O N S //
|
||
// //
|
||
//=========================================================================//
|
||
|
||
//---------------------------------------------------------------------------
|
||
//
|
||
// Function: EplEventkInit
|
||
//
|
||
// Description: function initializes the first instance
|
||
//
|
||
// Parameters: pfnCbSync_p = callback-function for sync event
|
||
//
|
||
// Returns: tEpKernel = errorcode
|
||
//
|
||
// State:
|
||
//
|
||
//---------------------------------------------------------------------------
|
||
|
||
tEplKernel PUBLIC EplEventkInit(tEplSyncCb pfnCbSync_p)
|
||
{
|
||
tEplKernel Ret;
|
||
|
||
Ret = EplEventkAddInstance(pfnCbSync_p);
|
||
|
||
return Ret;
|
||
|
||
}
|
||
|
||
//---------------------------------------------------------------------------
|
||
//
|
||
// Function: EplEventkAddInstance
|
||
//
|
||
// Description: function adds one more instance
|
||
//
|
||
// Parameters: pfnCbSync_p = callback-function for sync event
|
||
//
|
||
// Returns: tEpKernel = errorcode
|
||
//
|
||
// State:
|
||
//
|
||
//---------------------------------------------------------------------------
|
||
|
||
tEplKernel PUBLIC EplEventkAddInstance(tEplSyncCb pfnCbSync_p)
|
||
{
|
||
tEplKernel Ret;
|
||
#ifndef EPL_NO_FIFO
|
||
tShbError ShbError;
|
||
unsigned int fShbNewCreated;
|
||
#endif
|
||
|
||
Ret = kEplSuccessful;
|
||
|
||
// init instance structure
|
||
EplEventkInstance_g.m_uiUserToKernelFullCount = 0;
|
||
|
||
// save cb-function
|
||
EplEventkInstance_g.m_pfnCbSync = pfnCbSync_p;
|
||
|
||
#ifndef EPL_NO_FIFO
|
||
// init shared loop buffer
|
||
// kernel -> user
|
||
ShbError = ShbCirAllocBuffer(EPL_EVENT_SIZE_SHB_KERNEL_TO_USER,
|
||
EPL_EVENT_NAME_SHB_KERNEL_TO_USER,
|
||
&EplEventkInstance_g.
|
||
m_pShbKernelToUserInstance,
|
||
&fShbNewCreated);
|
||
if (ShbError != kShbOk) {
|
||
EPL_DBGLVL_EVENTK_TRACE1
|
||
("EplEventkAddInstance(): ShbCirAllocBuffer(K2U) -> 0x%X\n",
|
||
ShbError);
|
||
Ret = kEplNoResource;
|
||
goto Exit;
|
||
}
|
||
// user -> kernel
|
||
ShbError = ShbCirAllocBuffer(EPL_EVENT_SIZE_SHB_USER_TO_KERNEL,
|
||
EPL_EVENT_NAME_SHB_USER_TO_KERNEL,
|
||
&EplEventkInstance_g.
|
||
m_pShbUserToKernelInstance,
|
||
&fShbNewCreated);
|
||
if (ShbError != kShbOk) {
|
||
EPL_DBGLVL_EVENTK_TRACE1
|
||
("EplEventkAddInstance(): ShbCirAllocBuffer(U2K) -> 0x%X\n",
|
||
ShbError);
|
||
Ret = kEplNoResource;
|
||
goto Exit;
|
||
}
|
||
// register eventhandler
|
||
ShbError =
|
||
ShbCirSetSignalHandlerNewData(EplEventkInstance_g.
|
||
m_pShbUserToKernelInstance,
|
||
EplEventkRxSignalHandlerCb,
|
||
kshbPriorityHigh);
|
||
if (ShbError != kShbOk) {
|
||
EPL_DBGLVL_EVENTK_TRACE1
|
||
("EplEventkAddInstance(): ShbCirSetSignalHandlerNewData(U2K) -> 0x%X\n",
|
||
ShbError);
|
||
Ret = kEplNoResource;
|
||
goto Exit;
|
||
}
|
||
|
||
Exit:
|
||
#endif
|
||
|
||
return Ret;
|
||
|
||
}
|
||
|
||
//---------------------------------------------------------------------------
|
||
//
|
||
// Function: EplEventkDelInstance
|
||
//
|
||
// Description: function deletes instance and frees the buffers
|
||
//
|
||
// Parameters: void
|
||
//
|
||
// Returns: tEpKernel = errorcode
|
||
//
|
||
// State:
|
||
//
|
||
//---------------------------------------------------------------------------
|
||
|
||
tEplKernel PUBLIC EplEventkDelInstance()
|
||
{
|
||
tEplKernel Ret;
|
||
#ifndef EPL_NO_FIFO
|
||
tShbError ShbError;
|
||
#endif
|
||
|
||
Ret = kEplSuccessful;
|
||
|
||
#ifndef EPL_NO_FIFO
|
||
// set eventhandler to NULL
|
||
ShbError =
|
||
ShbCirSetSignalHandlerNewData(EplEventkInstance_g.
|
||
m_pShbUserToKernelInstance, NULL,
|
||
kShbPriorityNormal);
|
||
if (ShbError != kShbOk) {
|
||
EPL_DBGLVL_EVENTK_TRACE1
|
||
("EplEventkDelInstance(): ShbCirSetSignalHandlerNewData(U2K) -> 0x%X\n",
|
||
ShbError);
|
||
Ret = kEplNoResource;
|
||
}
|
||
// free buffer User -> Kernel
|
||
ShbError =
|
||
ShbCirReleaseBuffer(EplEventkInstance_g.m_pShbUserToKernelInstance);
|
||
if (ShbError != kShbOk) {
|
||
EPL_DBGLVL_EVENTK_TRACE1
|
||
("EplEventkDelInstance(): ShbCirReleaseBuffer(U2K) -> 0x%X\n",
|
||
ShbError);
|
||
Ret = kEplNoResource;
|
||
} else {
|
||
EplEventkInstance_g.m_pShbUserToKernelInstance = NULL;
|
||
}
|
||
|
||
// free buffer Kernel -> User
|
||
ShbError =
|
||
ShbCirReleaseBuffer(EplEventkInstance_g.m_pShbKernelToUserInstance);
|
||
if (ShbError != kShbOk) {
|
||
EPL_DBGLVL_EVENTK_TRACE1
|
||
("EplEventkDelInstance(): ShbCirReleaseBuffer(K2U) -> 0x%X\n",
|
||
ShbError);
|
||
Ret = kEplNoResource;
|
||
} else {
|
||
EplEventkInstance_g.m_pShbKernelToUserInstance = NULL;
|
||
}
|
||
#endif
|
||
|
||
return Ret;
|
||
|
||
}
|
||
|
||
//---------------------------------------------------------------------------
|
||
//
|
||
// Function: EplEventkProcess
|
||
//
|
||
// Description: Kernelthread that dispatches events in kernel part
|
||
//
|
||
// Parameters: pEvent_p = pointer to event-structure from buffer
|
||
//
|
||
// Returns: tEpKernel = errorcode
|
||
//
|
||
// State:
|
||
//
|
||
//---------------------------------------------------------------------------
|
||
|
||
tEplKernel PUBLIC EplEventkProcess(tEplEvent * pEvent_p)
|
||
{
|
||
tEplKernel Ret;
|
||
tEplEventSource EventSource;
|
||
|
||
Ret = kEplSuccessful;
|
||
|
||
// error handling if event queue is full
|
||
if (EplEventkInstance_g.m_uiUserToKernelFullCount > 0) { // UserToKernel event queue has run out of space -> kEplNmtEventInternComError
|
||
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) != 0)
|
||
tEplEvent Event;
|
||
tEplNmtEvent NmtEvent;
|
||
#endif
|
||
#ifndef EPL_NO_FIFO
|
||
tShbError ShbError;
|
||
#endif
|
||
|
||
// directly call NMTk process function, because event queue is full
|
||
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) != 0)
|
||
NmtEvent = kEplNmtEventInternComError;
|
||
Event.m_EventSink = kEplEventSinkNmtk;
|
||
Event.m_NetTime.m_dwNanoSec = 0;
|
||
Event.m_NetTime.m_dwSec = 0;
|
||
Event.m_EventType = kEplEventTypeNmtEvent;
|
||
Event.m_pArg = &NmtEvent;
|
||
Event.m_uiSize = sizeof(NmtEvent);
|
||
Ret = EplNmtkProcess(&Event);
|
||
#endif
|
||
|
||
// NMT state machine changed to reset (i.e. NMT_GS_RESET_COMMUNICATION)
|
||
// now, it is safe to reset the counter and empty the event queue
|
||
#ifndef EPL_NO_FIFO
|
||
ShbError =
|
||
ShbCirResetBuffer(EplEventkInstance_g.
|
||
m_pShbUserToKernelInstance, 1000, NULL);
|
||
#endif
|
||
|
||
EplEventkInstance_g.m_uiUserToKernelFullCount = 0;
|
||
TGT_DBG_SIGNAL_TRACE_POINT(22);
|
||
|
||
// also discard the current event (it doesn't matter if we lose another event)
|
||
goto Exit;
|
||
}
|
||
// check m_EventSink
|
||
switch (pEvent_p->m_EventSink) {
|
||
case kEplEventSinkSync:
|
||
{
|
||
if (EplEventkInstance_g.m_pfnCbSync != NULL) {
|
||
Ret = EplEventkInstance_g.m_pfnCbSync();
|
||
if (Ret == kEplSuccessful) {
|
||
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
|
||
// mark TPDOs as valid
|
||
Ret = EplPdokCalSetTpdosValid(TRUE);
|
||
#endif
|
||
} else if ((Ret != kEplReject)
|
||
&& (Ret != kEplShutdown)) {
|
||
EventSource = kEplEventSourceSyncCb;
|
||
|
||
// Error event for API layer
|
||
EplEventkPostError
|
||
(kEplEventSourceEventk, Ret,
|
||
sizeof(EventSource), &EventSource);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
|
||
// NMT-Kernel-Modul
|
||
case kEplEventSinkNmtk:
|
||
{
|
||
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) != 0)
|
||
Ret = EplNmtkProcess(pEvent_p);
|
||
if ((Ret != kEplSuccessful) && (Ret != kEplShutdown)) {
|
||
EventSource = kEplEventSourceNmtk;
|
||
|
||
// Error event for API layer
|
||
EplEventkPostError(kEplEventSourceEventk,
|
||
Ret,
|
||
sizeof(EventSource),
|
||
&EventSource);
|
||
}
|
||
#endif
|
||
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
|
||
if ((pEvent_p->m_EventType == kEplEventTypeNmtEvent)
|
||
&&
|
||
((*((tEplNmtEvent *) pEvent_p->m_pArg) ==
|
||
kEplNmtEventDllCeSoa)
|
||
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
|
||
|| (*((tEplNmtEvent *) pEvent_p->m_pArg) ==
|
||
kEplNmtEventDllMeSoaSent)
|
||
#endif
|
||
)) { // forward SoA event to error handler
|
||
Ret = EplErrorHandlerkProcess(pEvent_p);
|
||
if ((Ret != kEplSuccessful)
|
||
&& (Ret != kEplShutdown)) {
|
||
EventSource = kEplEventSourceErrk;
|
||
|
||
// Error event for API layer
|
||
EplEventkPostError
|
||
(kEplEventSourceEventk, Ret,
|
||
sizeof(EventSource), &EventSource);
|
||
}
|
||
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
|
||
// forward SoA event to PDO module
|
||
pEvent_p->m_EventType = kEplEventTypePdoSoa;
|
||
Ret = EplPdokProcess(pEvent_p);
|
||
if ((Ret != kEplSuccessful)
|
||
&& (Ret != kEplShutdown)) {
|
||
EventSource = kEplEventSourcePdok;
|
||
|
||
// Error event for API layer
|
||
EplEventkPostError
|
||
(kEplEventSourceEventk, Ret,
|
||
sizeof(EventSource), &EventSource);
|
||
}
|
||
#endif
|
||
|
||
}
|
||
break;
|
||
#endif
|
||
}
|
||
|
||
// events for Dllk module
|
||
case kEplEventSinkDllk:
|
||
{
|
||
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
|
||
Ret = EplDllkProcess(pEvent_p);
|
||
if ((Ret != kEplSuccessful) && (Ret != kEplShutdown)) {
|
||
EventSource = kEplEventSourceDllk;
|
||
|
||
// Error event for API layer
|
||
EplEventkPostError(kEplEventSourceEventk,
|
||
Ret,
|
||
sizeof(EventSource),
|
||
&EventSource);
|
||
}
|
||
#endif
|
||
break;
|
||
}
|
||
|
||
// events for DllkCal module
|
||
case kEplEventSinkDllkCal:
|
||
{
|
||
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
|
||
Ret = EplDllkCalProcess(pEvent_p);
|
||
if ((Ret != kEplSuccessful) && (Ret != kEplShutdown)) {
|
||
EventSource = kEplEventSourceDllk;
|
||
|
||
// Error event for API layer
|
||
EplEventkPostError(kEplEventSourceEventk,
|
||
Ret,
|
||
sizeof(EventSource),
|
||
&EventSource);
|
||
}
|
||
#endif
|
||
break;
|
||
}
|
||
|
||
//
|
||
case kEplEventSinkPdok:
|
||
{
|
||
// PDO-Module
|
||
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
|
||
Ret = EplPdokProcess(pEvent_p);
|
||
if ((Ret != kEplSuccessful) && (Ret != kEplShutdown)) {
|
||
EventSource = kEplEventSourcePdok;
|
||
|
||
// Error event for API layer
|
||
EplEventkPostError(kEplEventSourceEventk,
|
||
Ret,
|
||
sizeof(EventSource),
|
||
&EventSource);
|
||
}
|
||
#endif
|
||
break;
|
||
}
|
||
|
||
// events for Error handler module
|
||
case kEplEventSinkErrk:
|
||
{
|
||
// only call error handler if DLL is present
|
||
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
|
||
Ret = EplErrorHandlerkProcess(pEvent_p);
|
||
if ((Ret != kEplSuccessful) && (Ret != kEplShutdown)) {
|
||
EventSource = kEplEventSourceErrk;
|
||
|
||
// Error event for API layer
|
||
EplEventkPostError(kEplEventSourceEventk,
|
||
Ret,
|
||
sizeof(EventSource),
|
||
&EventSource);
|
||
}
|
||
break;
|
||
#endif
|
||
}
|
||
|
||
// unknown sink
|
||
default:
|
||
{
|
||
Ret = kEplEventUnknownSink;
|
||
}
|
||
|
||
} // end of switch(pEvent_p->m_EventSink)
|
||
|
||
Exit:
|
||
return Ret;
|
||
|
||
}
|
||
|
||
//---------------------------------------------------------------------------
|
||
//
|
||
// Function: EplEventkPost
|
||
//
|
||
// Description: post events from kernel part
|
||
//
|
||
// Parameters: pEvent_p = pointer to event-structure from buffer
|
||
//
|
||
// Returns: tEpKernel = errorcode
|
||
//
|
||
// State:
|
||
//
|
||
//---------------------------------------------------------------------------
|
||
|
||
tEplKernel PUBLIC EplEventkPost(tEplEvent * pEvent_p)
|
||
{
|
||
tEplKernel Ret;
|
||
#ifndef EPL_NO_FIFO
|
||
tShbError ShbError;
|
||
tShbCirChunk ShbCirChunk;
|
||
unsigned long ulDataSize;
|
||
unsigned int fBufferCompleted;
|
||
#endif
|
||
|
||
Ret = kEplSuccessful;
|
||
|
||
// the event must be posted by using the abBuffer
|
||
// it is neede because the Argument must by copied
|
||
// to the buffer too and not only the pointer
|
||
|
||
#ifndef EPL_NO_FIFO
|
||
// 2006/08/03 d.k.: Event and argument are posted as separate chunks to the event queue.
|
||
ulDataSize =
|
||
sizeof(tEplEvent) +
|
||
((pEvent_p->m_pArg != NULL) ? pEvent_p->m_uiSize : 0);
|
||
#endif
|
||
|
||
// decide in which buffer the event have to write
|
||
switch (pEvent_p->m_EventSink) {
|
||
// kernelspace modules
|
||
case kEplEventSinkSync:
|
||
case kEplEventSinkNmtk:
|
||
case kEplEventSinkDllk:
|
||
case kEplEventSinkDllkCal:
|
||
case kEplEventSinkPdok:
|
||
case kEplEventSinkErrk:
|
||
{
|
||
#ifndef EPL_NO_FIFO
|
||
// post message
|
||
BENCHMARK_MOD_27_SET(2);
|
||
ShbError =
|
||
ShbCirAllocDataBlock(EplEventkInstance_g.
|
||
m_pShbUserToKernelInstance,
|
||
&ShbCirChunk, ulDataSize);
|
||
switch (ShbError) {
|
||
case kShbOk:
|
||
break;
|
||
|
||
case kShbBufferFull:
|
||
{
|
||
EplEventkInstance_g.
|
||
m_uiUserToKernelFullCount++;
|
||
Ret = kEplEventPostError;
|
||
goto Exit;
|
||
}
|
||
|
||
default:
|
||
{
|
||
EPL_DBGLVL_EVENTK_TRACE1
|
||
("EplEventkPost(): ShbCirAllocDataBlock(U2K) -> 0x%X\n",
|
||
ShbError);
|
||
Ret = kEplEventPostError;
|
||
goto Exit;
|
||
}
|
||
}
|
||
ShbError =
|
||
ShbCirWriteDataChunk(EplEventkInstance_g.
|
||
m_pShbUserToKernelInstance,
|
||
&ShbCirChunk, pEvent_p,
|
||
sizeof(tEplEvent),
|
||
&fBufferCompleted);
|
||
if (ShbError != kShbOk) {
|
||
EPL_DBGLVL_EVENTK_TRACE1
|
||
("EplEventkPost(): ShbCirWriteDataChunk(U2K) -> 0x%X\n",
|
||
ShbError);
|
||
Ret = kEplEventPostError;
|
||
goto Exit;
|
||
}
|
||
if (fBufferCompleted == FALSE) {
|
||
ShbError =
|
||
ShbCirWriteDataChunk(EplEventkInstance_g.
|
||
m_pShbUserToKernelInstance,
|
||
&ShbCirChunk,
|
||
pEvent_p->m_pArg,
|
||
(unsigned long)
|
||
pEvent_p->m_uiSize,
|
||
&fBufferCompleted);
|
||
if ((ShbError != kShbOk)
|
||
|| (fBufferCompleted == FALSE)) {
|
||
EPL_DBGLVL_EVENTK_TRACE1
|
||
("EplEventkPost(): ShbCirWriteDataChunk2(U2K) -> 0x%X\n",
|
||
ShbError);
|
||
Ret = kEplEventPostError;
|
||
goto Exit;
|
||
}
|
||
}
|
||
BENCHMARK_MOD_27_RESET(2);
|
||
|
||
#else
|
||
Ret = EplEventkProcess(pEvent_p);
|
||
#endif
|
||
|
||
break;
|
||
}
|
||
|
||
// userspace modules
|
||
case kEplEventSinkNmtu:
|
||
case kEplEventSinkNmtMnu:
|
||
case kEplEventSinkSdoAsySeq:
|
||
case kEplEventSinkApi:
|
||
case kEplEventSinkDlluCal:
|
||
case kEplEventSinkErru:
|
||
{
|
||
#ifndef EPL_NO_FIFO
|
||
// post message
|
||
// BENCHMARK_MOD_27_SET(3); // 74 <20>s until reset
|
||
ShbError =
|
||
ShbCirAllocDataBlock(EplEventkInstance_g.
|
||
m_pShbKernelToUserInstance,
|
||
&ShbCirChunk, ulDataSize);
|
||
if (ShbError != kShbOk) {
|
||
EPL_DBGLVL_EVENTK_TRACE1
|
||
("EplEventkPost(): ShbCirAllocDataBlock(K2U) -> 0x%X\n",
|
||
ShbError);
|
||
Ret = kEplEventPostError;
|
||
goto Exit;
|
||
}
|
||
ShbError =
|
||
ShbCirWriteDataChunk(EplEventkInstance_g.
|
||
m_pShbKernelToUserInstance,
|
||
&ShbCirChunk, pEvent_p,
|
||
sizeof(tEplEvent),
|
||
&fBufferCompleted);
|
||
if (ShbError != kShbOk) {
|
||
EPL_DBGLVL_EVENTK_TRACE1
|
||
("EplEventkPost(): ShbCirWriteDataChunk(K2U) -> 0x%X\n",
|
||
ShbError);
|
||
Ret = kEplEventPostError;
|
||
goto Exit;
|
||
}
|
||
if (fBufferCompleted == FALSE) {
|
||
ShbError =
|
||
ShbCirWriteDataChunk(EplEventkInstance_g.
|
||
m_pShbKernelToUserInstance,
|
||
&ShbCirChunk,
|
||
pEvent_p->m_pArg,
|
||
(unsigned long)
|
||
pEvent_p->m_uiSize,
|
||
&fBufferCompleted);
|
||
if ((ShbError != kShbOk)
|
||
|| (fBufferCompleted == FALSE)) {
|
||
EPL_DBGLVL_EVENTK_TRACE1
|
||
("EplEventkPost(): ShbCirWriteDataChunk2(K2U) -> 0x%X\n",
|
||
ShbError);
|
||
Ret = kEplEventPostError;
|
||
goto Exit;
|
||
}
|
||
}
|
||
// BENCHMARK_MOD_27_RESET(3); // 82 <20>s until ShbCirGetReadDataSize() in EplEventu
|
||
|
||
#else
|
||
Ret = EplEventuProcess(pEvent_p);
|
||
#endif
|
||
|
||
break;
|
||
}
|
||
|
||
default:
|
||
{
|
||
Ret = kEplEventUnknownSink;
|
||
}
|
||
|
||
} // end of switch(pEvent_p->m_EventSink)
|
||
|
||
#ifndef EPL_NO_FIFO
|
||
Exit:
|
||
#endif
|
||
return Ret;
|
||
}
|
||
|
||
//---------------------------------------------------------------------------
|
||
//
|
||
// Function: EplEventkPostError
|
||
//
|
||
// Description: post error event from kernel part to API layer
|
||
//
|
||
// Parameters: EventSource_p = source-module of the error event
|
||
// EplError_p = code of occured error
|
||
// ArgSize_p = size of the argument
|
||
// pArg_p = pointer to the argument
|
||
//
|
||
// Returns: tEpKernel = errorcode
|
||
//
|
||
// State:
|
||
//
|
||
//---------------------------------------------------------------------------
|
||
|
||
tEplKernel PUBLIC EplEventkPostError(tEplEventSource EventSource_p,
|
||
tEplKernel EplError_p,
|
||
unsigned int uiArgSize_p, void *pArg_p)
|
||
{
|
||
tEplKernel Ret;
|
||
BYTE abBuffer[EPL_MAX_EVENT_ARG_SIZE];
|
||
tEplEventError *pEventError = (tEplEventError *) abBuffer;
|
||
tEplEvent EplEvent;
|
||
|
||
Ret = kEplSuccessful;
|
||
|
||
// create argument
|
||
pEventError->m_EventSource = EventSource_p;
|
||
pEventError->m_EplError = EplError_p;
|
||
EPL_MEMCPY(&pEventError->m_Arg, pArg_p, uiArgSize_p);
|
||
|
||
// create event
|
||
EplEvent.m_EventType = kEplEventTypeError;
|
||
EplEvent.m_EventSink = kEplEventSinkApi;
|
||
EPL_MEMSET(&EplEvent.m_NetTime, 0x00, sizeof(EplEvent.m_NetTime));
|
||
EplEvent.m_uiSize =
|
||
(sizeof(EventSource_p) + sizeof(EplError_p) + uiArgSize_p);
|
||
EplEvent.m_pArg = &abBuffer[0];
|
||
|
||
// post errorevent
|
||
Ret = EplEventkPost(&EplEvent);
|
||
|
||
return Ret;
|
||
}
|
||
|
||
//=========================================================================//
|
||
// //
|
||
// P R I V A T E F U N C T I O N S //
|
||
// //
|
||
//=========================================================================//
|
||
|
||
//---------------------------------------------------------------------------
|
||
//
|
||
// Function: EplEventkRxSignalHandlerCb()
|
||
//
|
||
// Description: Callback-function for events from user and kernel part
|
||
//
|
||
// Parameters: pShbRxInstance_p = Instance-pointer of buffer
|
||
// ulDataSize_p = size of data
|
||
//
|
||
// Returns: void
|
||
//
|
||
// State:
|
||
//
|
||
//---------------------------------------------------------------------------
|
||
|
||
#ifndef EPL_NO_FIFO
|
||
static void EplEventkRxSignalHandlerCb(tShbInstance pShbRxInstance_p,
|
||
unsigned long ulDataSize_p)
|
||
{
|
||
tEplEvent *pEplEvent;
|
||
tShbError ShbError;
|
||
//unsigned long ulBlockCount;
|
||
//unsigned long ulDataSize;
|
||
BYTE abDataBuffer[sizeof(tEplEvent) + EPL_MAX_EVENT_ARG_SIZE];
|
||
// d.k.: abDataBuffer contains the complete tEplEvent structure
|
||
// and behind this the argument
|
||
|
||
TGT_DBG_SIGNAL_TRACE_POINT(20);
|
||
|
||
BENCHMARK_MOD_27_RESET(0);
|
||
// copy data from event queue
|
||
ShbError = ShbCirReadDataBlock(pShbRxInstance_p,
|
||
&abDataBuffer[0],
|
||
sizeof(abDataBuffer), &ulDataSize_p);
|
||
if (ShbError != kShbOk) {
|
||
// error goto exit
|
||
goto Exit;
|
||
}
|
||
// resolve the pointer to the event structure
|
||
pEplEvent = (tEplEvent *) abDataBuffer;
|
||
// set Datasize
|
||
pEplEvent->m_uiSize = (ulDataSize_p - sizeof(tEplEvent));
|
||
if (pEplEvent->m_uiSize > 0) {
|
||
// set pointer to argument
|
||
pEplEvent->m_pArg = &abDataBuffer[sizeof(tEplEvent)];
|
||
} else {
|
||
//set pointer to NULL
|
||
pEplEvent->m_pArg = NULL;
|
||
}
|
||
|
||
BENCHMARK_MOD_27_SET(0);
|
||
// call processfunction
|
||
EplEventkProcess(pEplEvent);
|
||
|
||
Exit:
|
||
return;
|
||
}
|
||
#endif
|
||
|
||
// EOF
|