hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Staging: epl: remove PUBLIC definition 

It doesn't make sense here, so delete it.

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>
This commit is contained in:
Greg Kroah-Hartman 2009-03-23 10:45:12 -07:00
parent 335914e315
commit d10f46992f
64 changed files with 891 additions and 1079 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
drivers/staging/epl/Edrv8139.c
View File

@ -234,8 +234,8 @@
// TracePoint support for realtime-debugging // TracePoint support for realtime-debugging
#ifdef _DBG_TRACE_POINTS_ #ifdef _DBG_TRACE_POINTS_
void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p); void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p); void TgtDbgPostTraceValue(DWORD dwTraceValue_p);
#define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p) #define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p)
#define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v) #define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v)
#else #else

87
drivers/staging/epl/Epl.h
View File

@ -131,9 +131,9 @@ typedef union {
} tEplApiEventArg; } tEplApiEventArg;
typedef tEplKernel(PUBLIC ROM * tEplApiCbEvent) (tEplApiEventType EventType_p, // IN: event type (enum) typedef tEplKernel(ROM *tEplApiCbEvent) (tEplApiEventType EventType_p, // IN: event type (enum)
tEplApiEventArg * pEventArg_p, // IN: event argument (union) tEplApiEventArg *pEventArg_p, // IN: event argument (union)
void GENERIC * pUserArg_p); void GENERIC *pUserArg_p);
typedef struct { typedef struct {
unsigned int m_uiSizeOfStruct; unsigned int m_uiSizeOfStruct;
@ -212,62 +212,61 @@ typedef struct {
// function prototypes // function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplApiInitialize(tEplApiInitParam * pInitParam_p); tEplKernel EplApiInitialize(tEplApiInitParam *pInitParam_p);
tEplKernel PUBLIC EplApiShutdown(void); tEplKernel EplApiShutdown(void);
tEplKernel PUBLIC EplApiReadObject(tEplSdoComConHdl * pSdoComConHdl_p, tEplKernel EplApiReadObject(tEplSdoComConHdl *pSdoComConHdl_p,
unsigned int uiNodeId_p, unsigned int uiNodeId_p,
unsigned int uiIndex_p, unsigned int uiIndex_p,
unsigned int uiSubindex_p, unsigned int uiSubindex_p,
void *pDstData_le_p, void *pDstData_le_p,
unsigned int *puiSize_p, unsigned int *puiSize_p,
tEplSdoType SdoType_p, void *pUserArg_p); tEplSdoType SdoType_p, void *pUserArg_p);
tEplKernel PUBLIC EplApiWriteObject(tEplSdoComConHdl * pSdoComConHdl_p, tEplKernel EplApiWriteObject(tEplSdoComConHdl *pSdoComConHdl_p,
unsigned int uiNodeId_p, unsigned int uiNodeId_p,
unsigned int uiIndex_p, unsigned int uiIndex_p,
unsigned int uiSubindex_p, unsigned int uiSubindex_p,
void *pSrcData_le_p, void *pSrcData_le_p,
unsigned int uiSize_p, unsigned int uiSize_p,
tEplSdoType SdoType_p, void *pUserArg_p); tEplSdoType SdoType_p, void *pUserArg_p);
tEplKernel PUBLIC EplApiFreeSdoChannel(tEplSdoComConHdl SdoComConHdl_p); tEplKernel EplApiFreeSdoChannel(tEplSdoComConHdl SdoComConHdl_p);
tEplKernel PUBLIC EplApiReadLocalObject(unsigned int uiIndex_p, tEplKernel EplApiReadLocalObject(unsigned int uiIndex_p,
unsigned int uiSubindex_p, unsigned int uiSubindex_p,
void *pDstData_p, void *pDstData_p,
unsigned int *puiSize_p); unsigned int *puiSize_p);
tEplKernel PUBLIC EplApiWriteLocalObject(unsigned int uiIndex_p, tEplKernel EplApiWriteLocalObject(unsigned int uiIndex_p,
unsigned int uiSubindex_p, unsigned int uiSubindex_p,
void *pSrcData_p, void *pSrcData_p,
unsigned int uiSize_p); unsigned int uiSize_p);
tEplKernel PUBLIC EplApiCbObdAccess(tEplObdCbParam MEM * pParam_p); tEplKernel EplApiCbObdAccess(tEplObdCbParam MEM *pParam_p);
tEplKernel PUBLIC EplApiLinkObject(unsigned int uiObjIndex_p, tEplKernel EplApiLinkObject(unsigned int uiObjIndex_p,
void *pVar_p, void *pVar_p,
unsigned int *puiVarEntries_p, unsigned int *puiVarEntries_p,
tEplObdSize * pEntrySize_p, tEplObdSize *pEntrySize_p,
unsigned int uiFirstSubindex_p); unsigned int uiFirstSubindex_p);
tEplKernel PUBLIC EplApiExecNmtCommand(tEplNmtEvent NmtEvent_p); tEplKernel EplApiExecNmtCommand(tEplNmtEvent NmtEvent_p);
tEplKernel PUBLIC EplApiProcess(void); tEplKernel EplApiProcess(void);
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
tEplKernel PUBLIC EplApiMnTriggerStateChange(unsigned int uiNodeId_p, tEplKernel EplApiMnTriggerStateChange(unsigned int uiNodeId_p,
tEplNmtNodeCommand NodeCommand_p); tEplNmtNodeCommand NodeCommand_p);
#endif #endif
tEplKernel PUBLIC EplApiGetIdentResponse(unsigned int uiNodeId_p, tEplKernel EplApiGetIdentResponse(unsigned int uiNodeId_p,
tEplIdentResponse ** tEplIdentResponse **ppIdentResponse_p);
ppIdentResponse_p);
// functions for process image will be implemented in separate file // functions for process image will be implemented in separate file
tEplKernel PUBLIC EplApiProcessImageSetup(void); tEplKernel EplApiProcessImageSetup(void);
tEplKernel PUBLIC EplApiProcessImageExchangeIn(tEplApiProcessImage * pPI_p); tEplKernel EplApiProcessImageExchangeIn(tEplApiProcessImage *pPI_p);
tEplKernel PUBLIC EplApiProcessImageExchangeOut(tEplApiProcessImage * pPI_p); tEplKernel EplApiProcessImageExchangeOut(tEplApiProcessImage *pPI_p);
#endif // #ifndef _EPL_API_H_ #endif // #ifndef _EPL_API_H_

68
drivers/staging/epl/EplAmi.h
View File

@ -131,16 +131,16 @@ extern "C" {
// //
// To save code space the function AmiSetByte is replaced by // To save code space the function AmiSetByte is replaced by
// an macro. // an macro.
// void PUBLIC AmiSetByte (void FAR* pAddr_p, BYTE bByteVal_p); // void AmiSetByte (void FAR* pAddr_p, BYTE bByteVal_p);
#define AmiSetByteToBe(pAddr_p, bByteVal_p) {*(BYTE FAR*)(pAddr_p) = (bByteVal_p);} #define AmiSetByteToBe(pAddr_p, bByteVal_p) {*(BYTE FAR*)(pAddr_p) = (bByteVal_p);}
#define AmiSetByteToLe(pAddr_p, bByteVal_p) {*(BYTE FAR*)(pAddr_p) = (bByteVal_p);} #define AmiSetByteToLe(pAddr_p, bByteVal_p) {*(BYTE FAR*)(pAddr_p) = (bByteVal_p);}
#if !defined(INLINE_ENABLED) #if !defined(INLINE_ENABLED)
void PUBLIC AmiSetWordToBe(void FAR * pAddr_p, WORD wWordVal_p); void AmiSetWordToBe(void FAR *pAddr_p, WORD wWordVal_p);
void PUBLIC AmiSetDwordToBe(void FAR * pAddr_p, DWORD dwDwordVal_p); void AmiSetDwordToBe(void FAR *pAddr_p, DWORD dwDwordVal_p);
void PUBLIC AmiSetWordToLe(void FAR * pAddr_p, WORD wWordVal_p); void AmiSetWordToLe(void FAR *pAddr_p, WORD wWordVal_p);
void PUBLIC AmiSetDwordToLe(void FAR * pAddr_p, DWORD dwDwordVal_p); void AmiSetDwordToLe(void FAR *pAddr_p, DWORD dwDwordVal_p);
#endif #endif
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -149,17 +149,17 @@ extern "C" {
// //
// To save code space the function AmiGetByte is replaced by // To save code space the function AmiGetByte is replaced by
// an macro. // an macro.
// BYTE PUBLIC AmiGetByte (void FAR* pAddr_p); // BYTE AmiGetByte (void FAR* pAddr_p);
#define AmiGetByteFromBe(pAddr_p) (*(BYTE FAR*)(pAddr_p)) #define AmiGetByteFromBe(pAddr_p) (*(BYTE FAR*)(pAddr_p))
#define AmiGetByteFromLe(pAddr_p) (*(BYTE FAR*)(pAddr_p)) #define AmiGetByteFromLe(pAddr_p) (*(BYTE FAR*)(pAddr_p))
#if !defined(INLINE_ENABLED) #if !defined(INLINE_ENABLED)
WORD PUBLIC AmiGetWordFromBe(void FAR * pAddr_p); WORD AmiGetWordFromBe(void FAR *pAddr_p);
DWORD PUBLIC AmiGetDwordFromBe(void FAR * pAddr_p); DWORD AmiGetDwordFromBe(void FAR *pAddr_p);
WORD PUBLIC AmiGetWordFromLe(void FAR * pAddr_p); WORD AmiGetWordFromLe(void FAR *pAddr_p);
DWORD PUBLIC AmiGetDwordFromLe(void FAR * pAddr_p); DWORD AmiGetDwordFromLe(void FAR *pAddr_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// //
@ -174,8 +174,8 @@ extern "C" {
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void PUBLIC AmiSetDword24ToBe(void FAR * pAddr_p, DWORD dwDwordVal_p); void AmiSetDword24ToBe(void FAR *pAddr_p, DWORD dwDwordVal_p);
void PUBLIC AmiSetDword24ToLe(void FAR * pAddr_p, DWORD dwDwordVal_p); void AmiSetDword24ToLe(void FAR *pAddr_p, DWORD dwDwordVal_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// //
@ -189,8 +189,8 @@ extern "C" {
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
DWORD PUBLIC AmiGetDword24FromBe(void FAR * pAddr_p); DWORD AmiGetDword24FromBe(void FAR *pAddr_p);
DWORD PUBLIC AmiGetDword24FromLe(void FAR * pAddr_p); DWORD AmiGetDword24FromLe(void FAR *pAddr_p);
//#ifdef USE_VAR64 //#ifdef USE_VAR64
@ -207,8 +207,8 @@ extern "C" {
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void PUBLIC AmiSetQword40ToBe(void FAR * pAddr_p, QWORD qwQwordVal_p); void AmiSetQword40ToBe(void FAR *pAddr_p, QWORD qwQwordVal_p);
void PUBLIC AmiSetQword40ToLe(void FAR * pAddr_p, QWORD qwQwordVal_p); void AmiSetQword40ToLe(void FAR *pAddr_p, QWORD qwQwordVal_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// //
@ -222,8 +222,8 @@ extern "C" {
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
QWORD PUBLIC AmiGetQword40FromBe(void FAR * pAddr_p); QWORD AmiGetQword40FromBe(void FAR *pAddr_p);
QWORD PUBLIC AmiGetQword40FromLe(void FAR * pAddr_p); QWORD AmiGetQword40FromLe(void FAR *pAddr_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// //
@ -238,8 +238,8 @@ extern "C" {
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void PUBLIC AmiSetQword48ToBe(void FAR * pAddr_p, QWORD qwQwordVal_p); void AmiSetQword48ToBe(void FAR *pAddr_p, QWORD qwQwordVal_p);
void PUBLIC AmiSetQword48ToLe(void FAR * pAddr_p, QWORD qwQwordVal_p); void AmiSetQword48ToLe(void FAR *pAddr_p, QWORD qwQwordVal_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// //
@ -253,8 +253,8 @@ extern "C" {
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
QWORD PUBLIC AmiGetQword48FromBe(void FAR * pAddr_p); QWORD AmiGetQword48FromBe(void FAR *pAddr_p);
QWORD PUBLIC AmiGetQword48FromLe(void FAR * pAddr_p); QWORD AmiGetQword48FromLe(void FAR *pAddr_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// //
@ -269,8 +269,8 @@ extern "C" {
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void PUBLIC AmiSetQword56ToBe(void FAR * pAddr_p, QWORD qwQwordVal_p); void AmiSetQword56ToBe(void FAR *pAddr_p, QWORD qwQwordVal_p);
void PUBLIC AmiSetQword56ToLe(void FAR * pAddr_p, QWORD qwQwordVal_p); void AmiSetQword56ToLe(void FAR *pAddr_p, QWORD qwQwordVal_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// //
@ -284,8 +284,8 @@ extern "C" {
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
QWORD PUBLIC AmiGetQword56FromBe(void FAR * pAddr_p); QWORD AmiGetQword56FromBe(void FAR *pAddr_p);
QWORD PUBLIC AmiGetQword56FromLe(void FAR * pAddr_p); QWORD AmiGetQword56FromLe(void FAR *pAddr_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// //
@ -300,8 +300,8 @@ extern "C" {
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void PUBLIC AmiSetQword64ToBe(void FAR * pAddr_p, QWORD qwQwordVal_p); void AmiSetQword64ToBe(void FAR *pAddr_p, QWORD qwQwordVal_p);
void PUBLIC AmiSetQword64ToLe(void FAR * pAddr_p, QWORD qwQwordVal_p); void AmiSetQword64ToLe(void FAR *pAddr_p, QWORD qwQwordVal_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// //
@ -315,8 +315,8 @@ extern "C" {
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
QWORD PUBLIC AmiGetQword64FromBe(void FAR * pAddr_p); QWORD AmiGetQword64FromBe(void FAR *pAddr_p);
QWORD PUBLIC AmiGetQword64FromLe(void FAR * pAddr_p); QWORD AmiGetQword64FromLe(void FAR *pAddr_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// //
@ -330,9 +330,7 @@ extern "C" {
// Return: void // Return: void
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void AmiSetTimeOfDay(void FAR *pAddr_p, tTimeOfDay FAR *pTimeOfDay_p);
void PUBLIC AmiSetTimeOfDay(void FAR * pAddr_p,
tTimeOfDay FAR * pTimeOfDay_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// //
@ -346,9 +344,7 @@ extern "C" {
// Return: void // Return: void
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void AmiGetTimeOfDay(void FAR *pAddr_p, tTimeOfDay FAR *pTimeOfDay_p);
void PUBLIC AmiGetTimeOfDay(void FAR * pAddr_p,
tTimeOfDay FAR * pTimeOfDay_p);
#endif #endif

126
drivers/staging/epl/EplApiGeneric.c
View File

@ -162,44 +162,41 @@ static tEplApiInstance EplApiInstance_g;
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// NMT state change event callback function // NMT state change event callback function
static tEplKernel PUBLIC EplApiCbNmtStateChange(tEplEventNmtStateChange static tEplKernel EplApiCbNmtStateChange(tEplEventNmtStateChange NmtStateChange_p);
NmtStateChange_p);
// update DLL configuration from OD // update DLL configuration from OD
static tEplKernel PUBLIC EplApiUpdateDllConfig(BOOL fUpdateIdentity_p); static tEplKernel EplApiUpdateDllConfig(BOOL fUpdateIdentity_p);
// update OD from init param // update OD from init param
static tEplKernel PUBLIC EplApiUpdateObd(void); static tEplKernel EplApiUpdateObd(void);
// process events from user event queue // process events from user event queue
static tEplKernel PUBLIC EplApiProcessEvent(tEplEvent * pEplEvent_p); static tEplKernel EplApiProcessEvent(tEplEvent *pEplEvent_p);
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0) #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
// callback function of SDO module // callback function of SDO module
static tEplKernel PUBLIC EplApiCbSdoCon(tEplSdoComFinished * pSdoComFinished_p); static tEplKernel EplApiCbSdoCon(tEplSdoComFinished *pSdoComFinished_p);
#endif #endif
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
// callback functions of NmtMnu module // callback functions of NmtMnu module
static tEplKernel PUBLIC EplApiCbNodeEvent(unsigned int uiNodeId_p, static tEplKernel EplApiCbNodeEvent(unsigned int uiNodeId_p,
tEplNmtNodeEvent NodeEvent_p, tEplNmtNodeEvent NodeEvent_p,
tEplNmtState NmtState_p, tEplNmtState NmtState_p,
WORD wErrorCode_p, WORD wErrorCode_p, BOOL fMandatory_p);
BOOL fMandatory_p);
static tEplKernel PUBLIC EplApiCbBootEvent(tEplNmtBootEvent BootEvent_p, static tEplKernel EplApiCbBootEvent(tEplNmtBootEvent BootEvent_p,
tEplNmtState NmtState_p, tEplNmtState NmtState_p,
WORD wErrorCode_p); WORD wErrorCode_p);
#endif #endif
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0) #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0)
// callback function of Ledu module // callback function of Ledu module
static tEplKernel PUBLIC EplApiCbLedStateChange(tEplLedType LedType_p, static tEplKernel EplApiCbLedStateChange(tEplLedType LedType_p, BOOL fOn_p);
BOOL fOn_p);
#endif #endif
// OD initialization function (implemented in Objdict.c) // OD initialization function (implemented in Objdict.c)
tEplKernel PUBLIC EplObdInitRam(tEplObdInitParam MEM * pInitParam_p); tEplKernel EplObdInitRam(tEplObdInitParam MEM *pInitParam_p);
//=========================================================================// //=========================================================================//
// // // //
@ -226,7 +223,7 @@ tEplKernel PUBLIC EplObdInitRam(tEplObdInitParam MEM * pInitParam_p);
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplApiInitialize(tEplApiInitParam * pInitParam_p) tEplKernel EplApiInitialize(tEplApiInitParam *pInitParam_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
tEplObdInitParam ObdInitParam; tEplObdInitParam ObdInitParam;
@ -415,7 +412,7 @@ tEplKernel PUBLIC EplApiInitialize(tEplApiInitParam * pInitParam_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplApiShutdown(void) tEplKernel EplApiShutdown(void)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
@ -523,7 +520,7 @@ tEplKernel PUBLIC EplApiShutdown(void)
// State: // State:
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
tEplKernel PUBLIC EplApiExecNmtCommand(tEplNmtEvent NmtEvent_p) tEplKernel EplApiExecNmtCommand(tEplNmtEvent NmtEvent_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
@ -553,11 +550,11 @@ tEplKernel PUBLIC EplApiExecNmtCommand(tEplNmtEvent NmtEvent_p)
// State: // State:
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
tEplKernel PUBLIC EplApiLinkObject(unsigned int uiObjIndex_p, tEplKernel EplApiLinkObject(unsigned int uiObjIndex_p,
void *pVar_p, void *pVar_p,
unsigned int *puiVarEntries_p, unsigned int *puiVarEntries_p,
tEplObdSize * pEntrySize_p, tEplObdSize *pEntrySize_p,
unsigned int uiFirstSubindex_p) unsigned int uiFirstSubindex_p)
{ {
BYTE bVarEntries; BYTE bVarEntries;
BYTE bIndexEntries; BYTE bIndexEntries;
@ -677,13 +674,13 @@ tEplKernel PUBLIC EplApiLinkObject(unsigned int uiObjIndex_p,
// //
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
tEplKernel PUBLIC EplApiReadObject(tEplSdoComConHdl * pSdoComConHdl_p, tEplKernel EplApiReadObject(tEplSdoComConHdl *pSdoComConHdl_p,
unsigned int uiNodeId_p, unsigned int uiNodeId_p,
unsigned int uiIndex_p, unsigned int uiIndex_p,
unsigned int uiSubindex_p, unsigned int uiSubindex_p,
void *pDstData_le_p, void *pDstData_le_p,
unsigned int *puiSize_p, unsigned int *puiSize_p,
tEplSdoType SdoType_p, void *pUserArg_p) tEplSdoType SdoType_p, void *pUserArg_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
@ -765,13 +762,13 @@ tEplKernel PUBLIC EplApiReadObject(tEplSdoComConHdl * pSdoComConHdl_p,
// //
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
tEplKernel PUBLIC EplApiWriteObject(tEplSdoComConHdl * pSdoComConHdl_p, tEplKernel EplApiWriteObject(tEplSdoComConHdl *pSdoComConHdl_p,
unsigned int uiNodeId_p, unsigned int uiNodeId_p,
unsigned int uiIndex_p, unsigned int uiIndex_p,
unsigned int uiSubindex_p, unsigned int uiSubindex_p,
void *pSrcData_le_p, void *pSrcData_le_p,
unsigned int uiSize_p, unsigned int uiSize_p,
tEplSdoType SdoType_p, void *pUserArg_p) tEplSdoType SdoType_p, void *pUserArg_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
@ -850,7 +847,7 @@ tEplKernel PUBLIC EplApiWriteObject(tEplSdoComConHdl * pSdoComConHdl_p,
// //
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
tEplKernel PUBLIC EplApiFreeSdoChannel(tEplSdoComConHdl SdoComConHdl_p) tEplKernel EplApiFreeSdoChannel(tEplSdoComConHdl SdoComConHdl_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
@ -881,10 +878,9 @@ tEplKernel PUBLIC EplApiFreeSdoChannel(tEplSdoComConHdl SdoComConHdl_p)
// //
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
tEplKernel PUBLIC EplApiReadLocalObject(unsigned int uiIndex_p, tEplKernel EplApiReadLocalObject(unsigned int uiIndex_p,
unsigned int uiSubindex_p, unsigned int uiSubindex_p,
void *pDstData_p, void *pDstData_p, unsigned int *puiSize_p)
unsigned int *puiSize_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
tEplObdSize ObdSize; tEplObdSize ObdSize;
@ -911,10 +907,10 @@ tEplKernel PUBLIC EplApiReadLocalObject(unsigned int uiIndex_p,
// //
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
tEplKernel PUBLIC EplApiWriteLocalObject(unsigned int uiIndex_p, tEplKernel EplApiWriteLocalObject(unsigned int uiIndex_p,
unsigned int uiSubindex_p, unsigned int uiSubindex_p,
void *pSrcData_p, void *pSrcData_p,
unsigned int uiSize_p) unsigned int uiSize_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
@ -939,8 +935,8 @@ tEplKernel PUBLIC EplApiWriteLocalObject(unsigned int uiIndex_p,
// //
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
tEplKernel PUBLIC EplApiMnTriggerStateChange(unsigned int uiNodeId_p, tEplKernel EplApiMnTriggerStateChange(unsigned int uiNodeId_p,
tEplNmtNodeCommand NodeCommand_p) tEplNmtNodeCommand NodeCommand_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
@ -966,7 +962,7 @@ tEplKernel PUBLIC EplApiMnTriggerStateChange(unsigned int uiNodeId_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplApiCbObdAccess(tEplObdCbParam MEM * pParam_p) tEplKernel EplApiCbObdAccess(tEplObdCbParam MEM *pParam_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
@ -1115,7 +1111,7 @@ tEplKernel PUBLIC EplApiCbObdAccess(tEplObdCbParam MEM * pParam_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplApiProcessEvent(tEplEvent * pEplEvent_p) static tEplKernel EplApiProcessEvent(tEplEvent *pEplEvent_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplEventError *pEventError; tEplEventError *pEventError;
@ -1188,8 +1184,7 @@ static tEplKernel PUBLIC EplApiProcessEvent(tEplEvent * pEplEvent_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplApiCbNmtStateChange(tEplEventNmtStateChange static tEplKernel EplApiCbNmtStateChange(tEplEventNmtStateChange NmtStateChange_p)
NmtStateChange_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
BYTE bNmtState; BYTE bNmtState;
@ -1411,7 +1406,7 @@ static tEplKernel PUBLIC EplApiCbNmtStateChange(tEplEventNmtStateChange
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplApiUpdateDllConfig(BOOL fUpdateIdentity_p) static tEplKernel EplApiUpdateDllConfig(BOOL fUpdateIdentity_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
tEplDllConfigParam DllConfigParam; tEplDllConfigParam DllConfigParam;
@ -1634,7 +1629,7 @@ static tEplKernel PUBLIC EplApiUpdateDllConfig(BOOL fUpdateIdentity_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplApiUpdateObd(void) static tEplKernel EplApiUpdateObd(void)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
WORD wTemp; WORD wTemp;
@ -1905,7 +1900,7 @@ static tEplKernel PUBLIC EplApiUpdateObd(void)
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0) #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
static tEplKernel PUBLIC EplApiCbSdoCon(tEplSdoComFinished * pSdoComFinished_p) static tEplKernel EplApiCbSdoCon(tEplSdoComFinished *pSdoComFinished_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplApiEventArg EventArg; tEplApiEventArg EventArg;
@ -1946,10 +1941,10 @@ static tEplKernel PUBLIC EplApiCbSdoCon(tEplSdoComFinished * pSdoComFinished_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplApiCbNodeEvent(unsigned int uiNodeId_p, static tEplKernel EplApiCbNodeEvent(unsigned int uiNodeId_p,
tEplNmtNodeEvent NodeEvent_p, tEplNmtNodeEvent NodeEvent_p,
tEplNmtState NmtState_p, tEplNmtState NmtState_p,
WORD wErrorCode_p, BOOL fMandatory_p) WORD wErrorCode_p, BOOL fMandatory_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplApiEventArg EventArg; tEplApiEventArg EventArg;
@ -1990,9 +1985,9 @@ static tEplKernel PUBLIC EplApiCbNodeEvent(unsigned int uiNodeId_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplApiCbBootEvent(tEplNmtBootEvent BootEvent_p, static tEplKernel EplApiCbBootEvent(tEplNmtBootEvent BootEvent_p,
tEplNmtState NmtState_p, tEplNmtState NmtState_p,
WORD wErrorCode_p) WORD wErrorCode_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplApiEventArg EventArg; tEplApiEventArg EventArg;
@ -2033,8 +2028,7 @@ static tEplKernel PUBLIC EplApiCbBootEvent(tEplNmtBootEvent BootEvent_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplApiCbLedStateChange(tEplLedType LedType_p, static tEplKernel EplApiCbLedStateChange(tEplLedType LedType_p, BOOL fOn_p)
BOOL fOn_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplApiEventArg EventArg; tEplApiEventArg EventArg;

18
drivers/staging/epl/EplApiLinuxKernel.c
View File

@ -139,7 +139,7 @@ MODULE_DESCRIPTION("EPL API driver");
// TracePoint support for realtime-debugging // TracePoint support for realtime-debugging
#ifdef _DBG_TRACE_POINTS_ #ifdef _DBG_TRACE_POINTS_
void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p); void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
#define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p) #define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p)
#else #else
#define TGT_DBG_SIGNAL_TRACE_POINT(p) #define TGT_DBG_SIGNAL_TRACE_POINT(p)
@ -204,11 +204,11 @@ typedef struct {
// Prototypes of internal functions // Prototypes of internal functions
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplLinCbEvent(tEplApiEventType EventType_p, // IN: event type (enum) tEplKernel EplLinCbEvent(tEplApiEventType EventType_p, // IN: event type (enum)
tEplApiEventArg * pEventArg_p, // IN: event argument (union) tEplApiEventArg *pEventArg_p, // IN: event argument (union)
void GENERIC * pUserArg_p); void GENERIC *pUserArg_p);
tEplKernel PUBLIC EplLinCbSync(void); tEplKernel EplLinCbSync(void);
static int __init EplLinInit(void); static int __init EplLinInit(void);
static void __exit EplLinExit(void); static void __exit EplLinExit(void);
@ -1158,9 +1158,9 @@ static int EplLinIoctl(struct inode *pDeviceFile_p, // information about the dev
// // // //
//=========================================================================// //=========================================================================//
tEplKernel PUBLIC EplLinCbEvent(tEplApiEventType EventType_p, // IN: event type (enum) tEplKernel EplLinCbEvent(tEplApiEventType EventType_p, // IN: event type (enum)
tEplApiEventArg * pEventArg_p, // IN: event argument (union) tEplApiEventArg *pEventArg_p, // IN: event argument (union)
void GENERIC * pUserArg_p) void GENERIC *pUserArg_p)
{ {
tEplKernel EplRet = kEplSuccessful; tEplKernel EplRet = kEplSuccessful;
int iErr; int iErr;
@ -1224,7 +1224,7 @@ tEplKernel PUBLIC EplLinCbEvent(tEplApiEventType EventType_p, // IN: event type
return EplRet; return EplRet;
} }
tEplKernel PUBLIC EplLinCbSync(void) tEplKernel EplLinCbSync(void)
{ {
tEplKernel EplRet = kEplSuccessful; tEplKernel EplRet = kEplSuccessful;
int iErr; int iErr;

6
drivers/staging/epl/EplApiProcessImage.c
View File

@ -169,7 +169,7 @@ static tEplApiProcessImageInstance EplApiProcessImageInstance_g;
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplApiProcessImageSetup(void) tEplKernel EplApiProcessImageSetup(void)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
#if ((EPL_API_PROCESS_IMAGE_SIZE_IN > 0) || (EPL_API_PROCESS_IMAGE_SIZE_OUT > 0)) #if ((EPL_API_PROCESS_IMAGE_SIZE_IN > 0) || (EPL_API_PROCESS_IMAGE_SIZE_OUT > 0))
@ -280,7 +280,7 @@ tEplKernel PUBLIC EplApiProcessImageSetup(void)
// State: // State:
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
tEplKernel PUBLIC EplApiProcessImageExchangeIn(tEplApiProcessImage * pPI_p) tEplKernel EplApiProcessImageExchangeIn(tEplApiProcessImage *pPI_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
@ -315,7 +315,7 @@ tEplKernel PUBLIC EplApiProcessImageExchangeIn(tEplApiProcessImage * pPI_p)
// State: // State:
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
tEplKernel PUBLIC EplApiProcessImageExchangeOut(tEplApiProcessImage * pPI_p) tEplKernel EplApiProcessImageExchangeOut(tEplApiProcessImage *pPI_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;

18
drivers/staging/epl/EplDllk.c
View File

@ -121,8 +121,8 @@
// TracePoint support for realtime-debugging // TracePoint support for realtime-debugging
#ifdef _DBG_TRACE_POINTS_ #ifdef _DBG_TRACE_POINTS_
void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p); void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p); void TgtDbgPostTraceValue(DWORD dwTraceValue_p);
#define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p) #define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p)
#define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v) #define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v)
#else #else
@ -257,7 +257,7 @@ static tEplKernel EplDllkCheckFrame(tEplFrame * pFrame_p,
// called by high resolution timer module to monitor EPL cycle as CN // called by high resolution timer module to monitor EPL cycle as CN
#if EPL_TIMER_USE_HIGHRES != FALSE #if EPL_TIMER_USE_HIGHRES != FALSE
static tEplKernel PUBLIC EplDllkCbCnTimer(tEplTimerEventArg * pEventArg_p); static tEplKernel EplDllkCbCnTimer(tEplTimerEventArg *pEventArg_p);
#endif #endif
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
@ -278,10 +278,9 @@ static tEplKernel EplDllkAsyncFrameNotReceived(tEplDllReqServiceId
ReqServiceId_p, ReqServiceId_p,
unsigned int uiNodeId_p); unsigned int uiNodeId_p);
static tEplKernel PUBLIC EplDllkCbMnTimerCycle(tEplTimerEventArg * pEventArg_p); static tEplKernel EplDllkCbMnTimerCycle(tEplTimerEventArg *pEventArg_p);
static tEplKernel PUBLIC EplDllkCbMnTimerResponse(tEplTimerEventArg * static tEplKernel EplDllkCbMnTimerResponse(tEplTimerEventArg *pEventArg_p);
pEventArg_p);
#endif #endif
@ -3546,7 +3545,7 @@ static tEplKernel EplDllkCheckFrame(tEplFrame * pFrame_p,
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if EPL_TIMER_USE_HIGHRES != FALSE #if EPL_TIMER_USE_HIGHRES != FALSE
static tEplKernel PUBLIC EplDllkCbCnTimer(tEplTimerEventArg * pEventArg_p) static tEplKernel EplDllkCbCnTimer(tEplTimerEventArg *pEventArg_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
tEplNmtState NmtState; tEplNmtState NmtState;
@ -3617,7 +3616,7 @@ static tEplKernel PUBLIC EplDllkCbCnTimer(tEplTimerEventArg * pEventArg_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplDllkCbMnTimerCycle(tEplTimerEventArg * pEventArg_p) static tEplKernel EplDllkCbMnTimerCycle(tEplTimerEventArg *pEventArg_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
tEplNmtState NmtState; tEplNmtState NmtState;
@ -3670,8 +3669,7 @@ static tEplKernel PUBLIC EplDllkCbMnTimerCycle(tEplTimerEventArg * pEventArg_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplDllkCbMnTimerResponse(tEplTimerEventArg * static tEplKernel EplDllkCbMnTimerResponse(tEplTimerEventArg *pEventArg_p)
pEventArg_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
tEplNmtState NmtState; tEplNmtState NmtState;

8
drivers/staging/epl/EplErrorHandlerk.c
View File

@ -176,7 +176,7 @@ static tEplKernel EplErrorHandlerkLinkArray(DWORD * pdwValue_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplErrorHandlerkInit(void) tEplKernel EplErrorHandlerkInit(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -203,7 +203,7 @@ tEplKernel PUBLIC EplErrorHandlerkInit(void)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplErrorHandlerkAddInstance(void) tEplKernel EplErrorHandlerkAddInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -306,7 +306,7 @@ tEplKernel PUBLIC EplErrorHandlerkAddInstance(void)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplErrorHandlerkDelInstance() tEplKernel EplErrorHandlerkDelInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -333,7 +333,7 @@ tEplKernel PUBLIC EplErrorHandlerkDelInstance()
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplErrorHandlerkProcess(tEplEvent * pEvent_p) tEplKernel EplErrorHandlerkProcess(tEplEvent *pEvent_p)
{ {
tEplKernel Ret; tEplKernel Ret;
unsigned long ulDllErrorEvents; unsigned long ulDllErrorEvents;

4
drivers/staging/epl/EplEvent.h
View File

@ -267,10 +267,10 @@ typedef struct {
} tEplErrorHandlerkEvent; } tEplErrorHandlerkEvent;
// callback function to get informed about sync event // callback function to get informed about sync event
typedef tEplKernel(PUBLIC * tEplSyncCb) (void); typedef tEplKernel(*tEplSyncCb) (void);
// callback function for generic events // callback function for generic events
typedef tEplKernel(PUBLIC * tEplProcessEventCb) (tEplEvent * pEplEvent_p); typedef tEplKernel(*tEplProcessEventCb) (tEplEvent *pEplEvent_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// function prototypes // function prototypes

20
drivers/staging/epl/EplEventk.c
View File

@ -100,8 +100,8 @@
// TracePoint support for realtime-debugging // TracePoint support for realtime-debugging
#ifdef _DBG_TRACE_POINTS_ #ifdef _DBG_TRACE_POINTS_
void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p); void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p); void TgtDbgPostTraceValue(DWORD dwTraceValue_p);
#define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p) #define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p)
#define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v) #define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v)
#else #else
@ -172,7 +172,7 @@ static void EplEventkRxSignalHandlerCb(tShbInstance pShbRxInstance_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplEventkInit(tEplSyncCb pfnCbSync_p) tEplKernel EplEventkInit(tEplSyncCb pfnCbSync_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -196,7 +196,7 @@ tEplKernel PUBLIC EplEventkInit(tEplSyncCb pfnCbSync_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplEventkAddInstance(tEplSyncCb pfnCbSync_p) tEplKernel EplEventkAddInstance(tEplSyncCb pfnCbSync_p)
{ {
tEplKernel Ret; tEplKernel Ret;
#ifndef EPL_NO_FIFO #ifndef EPL_NO_FIFO
@ -275,7 +275,7 @@ tEplKernel PUBLIC EplEventkAddInstance(tEplSyncCb pfnCbSync_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplEventkDelInstance() tEplKernel EplEventkDelInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
#ifndef EPL_NO_FIFO #ifndef EPL_NO_FIFO
@ -339,7 +339,7 @@ tEplKernel PUBLIC EplEventkDelInstance()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplEventkProcess(tEplEvent * pEvent_p) tEplKernel EplEventkProcess(tEplEvent *pEvent_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplEventSource EventSource; tEplEventSource EventSource;
@ -562,7 +562,7 @@ tEplKernel PUBLIC EplEventkProcess(tEplEvent * pEvent_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplEventkPost(tEplEvent * pEvent_p) tEplKernel EplEventkPost(tEplEvent *pEvent_p)
{ {
tEplKernel Ret; tEplKernel Ret;
#ifndef EPL_NO_FIFO #ifndef EPL_NO_FIFO
@ -755,9 +755,9 @@ tEplKernel PUBLIC EplEventkPost(tEplEvent * pEvent_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplEventkPostError(tEplEventSource EventSource_p, tEplKernel EplEventkPostError(tEplEventSource EventSource_p,
tEplKernel EplError_p, tEplKernel EplError_p,
unsigned int uiArgSize_p, void *pArg_p) unsigned int uiArgSize_p, void *pArg_p)
{ {
tEplKernel Ret; tEplKernel Ret;
BYTE abBuffer[EPL_MAX_EVENT_ARG_SIZE]; BYTE abBuffer[EPL_MAX_EVENT_ARG_SIZE];

21
drivers/staging/epl/EplEventu.c
View File

@ -96,8 +96,8 @@
// TracePoint support for realtime-debugging // TracePoint support for realtime-debugging
#ifdef _DBG_TRACE_POINTS_ #ifdef _DBG_TRACE_POINTS_
void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p); void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p); void TgtDbgPostTraceValue(DWORD dwTraceValue_p);
#define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p) #define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p)
#define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v) #define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v)
#else #else
@ -172,7 +172,7 @@ static void EplEventuRxSignalHandlerCb(tShbInstance pShbRxInstance_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplEventuInit(tEplProcessEventCb pfnApiProcessEventCb_p) tEplKernel EplEventuInit(tEplProcessEventCb pfnApiProcessEventCb_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -199,8 +199,7 @@ tEplKernel PUBLIC EplEventuInit(tEplProcessEventCb pfnApiProcessEventCb_p)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplEventuAddInstance(tEplProcessEventCb tEplKernel EplEventuAddInstance(tEplProcessEventCb pfnApiProcessEventCb_p)
pfnApiProcessEventCb_p)
{ {
tEplKernel Ret; tEplKernel Ret;
#ifndef EPL_NO_FIFO #ifndef EPL_NO_FIFO
@ -280,7 +279,7 @@ tEplKernel PUBLIC EplEventuAddInstance(tEplProcessEventCb
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplEventuDelInstance() tEplKernel EplEventuDelInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
#ifndef EPL_NO_FIFO #ifndef EPL_NO_FIFO
@ -348,7 +347,7 @@ tEplKernel PUBLIC EplEventuDelInstance()
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplEventuProcess(tEplEvent * pEvent_p) tEplKernel EplEventuProcess(tEplEvent *pEvent_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplEventSource EventSource; tEplEventSource EventSource;
@ -515,7 +514,7 @@ tEplKernel PUBLIC EplEventuProcess(tEplEvent * pEvent_p)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplEventuPost(tEplEvent * pEvent_p) tEplKernel EplEventuPost(tEplEvent *pEvent_p)
{ {
tEplKernel Ret; tEplKernel Ret;
#ifndef EPL_NO_FIFO #ifndef EPL_NO_FIFO
@ -689,9 +688,9 @@ tEplKernel PUBLIC EplEventuPost(tEplEvent * pEvent_p)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplEventuPostError(tEplEventSource EventSource_p, tEplKernel EplEventuPostError(tEplEventSource EventSource_p,
tEplKernel EplError_p, tEplKernel EplError_p,
unsigned int uiArgSize_p, void *pArg_p) unsigned int uiArgSize_p, void *pArg_p)
{ {
tEplKernel Ret; tEplKernel Ret;
BYTE abBuffer[EPL_MAX_EVENT_ARG_SIZE]; BYTE abBuffer[EPL_MAX_EVENT_ARG_SIZE];

24
drivers/staging/epl/EplIdentu.c
View File

@ -138,7 +138,7 @@ static tEplIdentuInstance EplIdentuInstance_g;
// local function prototypes // local function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplIdentuCbIdentResponse(tEplFrameInfo * pFrameInfo_p); static tEplKernel EplIdentuCbIdentResponse(tEplFrameInfo *pFrameInfo_p);
//=========================================================================// //=========================================================================//
// // // //
@ -164,7 +164,7 @@ static tEplKernel PUBLIC EplIdentuCbIdentResponse(tEplFrameInfo * pFrameInfo_p);
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplIdentuInit() EPLDLLEXPORT tEplKernel EplIdentuInit(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -191,7 +191,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplIdentuInit()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplIdentuAddInstance() EPLDLLEXPORT tEplKernel EplIdentuAddInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -228,7 +228,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplIdentuAddInstance()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplIdentuDelInstance() EPLDLLEXPORT tEplKernel EplIdentuDelInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -263,7 +263,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplIdentuDelInstance()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplIdentuReset() EPLDLLEXPORT tEplKernel EplIdentuReset(void)
{ {
tEplKernel Ret; tEplKernel Ret;
int iIndex; int iIndex;
@ -300,9 +300,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplIdentuReset()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplIdentuGetIdentResponse(unsigned int uiNodeId_p, tEplKernel EplIdentuGetIdentResponse(unsigned int uiNodeId_p,
tEplIdentResponse ** tEplIdentResponse **ppIdentResponse_p)
ppIdentResponse_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -338,9 +337,8 @@ tEplKernel PUBLIC EplIdentuGetIdentResponse(unsigned int uiNodeId_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplIdentuRequestIdentResponse(unsigned int uiNodeId_p, tEplKernel EplIdentuRequestIdentResponse(unsigned int uiNodeId_p,
tEplIdentuCbResponse tEplIdentuCbResponse pfnCbResponse_p)
pfnCbResponse_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -388,7 +386,7 @@ tEplKernel PUBLIC EplIdentuRequestIdentResponse(unsigned int uiNodeId_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT DWORD PUBLIC EplIdentuGetRunningRequests(void) EPLDLLEXPORT DWORD EplIdentuGetRunningRequests(void)
{ {
DWORD dwReqs = 0; DWORD dwReqs = 0;
unsigned int uiIndex; unsigned int uiIndex;
@ -426,7 +424,7 @@ EPLDLLEXPORT DWORD PUBLIC EplIdentuGetRunningRequests(void)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplIdentuCbIdentResponse(tEplFrameInfo * pFrameInfo_p) static tEplKernel EplIdentuCbIdentResponse(tEplFrameInfo *pFrameInfo_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
unsigned int uiNodeId; unsigned int uiNodeId;

19
drivers/staging/epl/EplNmtCnu.c
View File

@ -110,7 +110,7 @@ static tEplNmtCommand EplNmtCnuGetNmtCommand(tEplFrameInfo * pFrameInfo_p);
static BOOL EplNmtCnuNodeIdList(BYTE * pbNmtCommandDate_p); static BOOL EplNmtCnuNodeIdList(BYTE * pbNmtCommandDate_p);
static tEplKernel PUBLIC EplNmtCnuCommandCb(tEplFrameInfo * pFrameInfo_p); static tEplKernel EplNmtCnuCommandCb(tEplFrameInfo *pFrameInfo_p);
//=========================================================================// //=========================================================================//
// // // //
@ -135,7 +135,7 @@ static tEplKernel PUBLIC EplNmtCnuCommandCb(tEplFrameInfo * pFrameInfo_p);
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuInit(unsigned int uiNodeId_p) EPLDLLEXPORT tEplKernel EplNmtCnuInit(unsigned int uiNodeId_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -161,7 +161,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuInit(unsigned int uiNodeId_p)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuAddInstance(unsigned int uiNodeId_p) EPLDLLEXPORT tEplKernel EplNmtCnuAddInstance(unsigned int uiNodeId_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -201,7 +201,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuAddInstance(unsigned int uiNodeId_p)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuDelInstance() EPLDLLEXPORT tEplKernel EplNmtCnuDelInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -234,9 +234,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuDelInstance()
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuSendNmtRequest(unsigned int uiNodeId_p, EPLDLLEXPORT tEplKernel EplNmtCnuSendNmtRequest(unsigned int uiNodeId_p,
tEplNmtCommand tEplNmtCommand NmtCommand_p)
NmtCommand_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplFrameInfo NmtRequestFrameInfo; tEplFrameInfo NmtRequestFrameInfo;
@ -297,9 +296,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuSendNmtRequest(unsigned int uiNodeId_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EPLDLLEXPORT tEplKernel EplNmtCnuRegisterCheckEventCb(tEplNmtuCheckEventCallback pfnEplNmtCheckEventCb_p)
EplNmtCnuRegisterCheckEventCb(tEplNmtuCheckEventCallback
pfnEplNmtCheckEventCb_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -335,7 +332,7 @@ EplNmtCnuRegisterCheckEventCb(tEplNmtuCheckEventCallback
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplNmtCnuCommandCb(tEplFrameInfo * pFrameInfo_p) static tEplKernel EplNmtCnuCommandCb(tEplFrameInfo *pFrameInfo_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
tEplNmtCommand NmtCommand; tEplNmtCommand NmtCommand;

43
drivers/staging/epl/EplNmtMnu.c
View File

@ -94,8 +94,8 @@
// TracePoint support for realtime-debugging // TracePoint support for realtime-debugging
#ifdef _DBG_TRACE_POINTS_ #ifdef _DBG_TRACE_POINTS_
void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p); void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p); void TgtDbgPostTraceValue(DWORD dwTraceValue_p);
#define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p) #define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p)
#define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v) #define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v)
#else #else
@ -241,15 +241,13 @@ static tEplNmtMnuInstance EplNmtMnuInstance_g;
// local function prototypes // local function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplNmtMnuCbNmtRequest(tEplFrameInfo * pFrameInfo_p); static tEplKernel EplNmtMnuCbNmtRequest(tEplFrameInfo *pFrameInfo_p);
static tEplKernel PUBLIC EplNmtMnuCbIdentResponse(unsigned int uiNodeId_p, static tEplKernel EplNmtMnuCbIdentResponse(unsigned int uiNodeId_p,
tEplIdentResponse * tEplIdentResponse *pIdentResponse_p);
pIdentResponse_p);
static tEplKernel PUBLIC EplNmtMnuCbStatusResponse(unsigned int uiNodeId_p, static tEplKernel EplNmtMnuCbStatusResponse(unsigned int uiNodeId_p,
tEplStatusResponse * tEplStatusResponse *pStatusResponse_p);
pStatusResponse_p);
static tEplKernel EplNmtMnuCheckNmtState(unsigned int uiNodeId_p, static tEplKernel EplNmtMnuCheckNmtState(unsigned int uiNodeId_p,
tEplNmtMnuNodeInfo * pNodeInfo_p, tEplNmtMnuNodeInfo * pNodeInfo_p,
@ -645,8 +643,7 @@ tEplKernel EplNmtMnuTriggerStateChange(unsigned int uiNodeId_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplNmtMnuCbNmtStateChange(tEplEventNmtStateChange tEplKernel EplNmtMnuCbNmtStateChange(tEplEventNmtStateChange NmtStateChange_p)
NmtStateChange_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
@ -928,7 +925,7 @@ tEplKernel PUBLIC EplNmtMnuCbNmtStateChange(tEplEventNmtStateChange
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplNmtMnuCbCheckEvent(tEplNmtEvent NmtEvent_p) tEplKernel EplNmtMnuCbCheckEvent(tEplNmtEvent NmtEvent_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
@ -949,7 +946,7 @@ tEplKernel PUBLIC EplNmtMnuCbCheckEvent(tEplNmtEvent NmtEvent_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplNmtMnuProcessEvent(tEplEvent * pEvent_p) EPLDLLEXPORT tEplKernel EplNmtMnuProcessEvent(tEplEvent *pEvent_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -1258,11 +1255,9 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtMnuProcessEvent(tEplEvent * pEvent_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplNmtMnuGetDiagnosticInfo(unsigned int tEplKernel EplNmtMnuGetDiagnosticInfo(unsigned int *puiMandatorySlaveCount_p,
*puiMandatorySlaveCount_p, unsigned int *puiSignalSlaveCount_p,
unsigned int WORD *pwFlags_p)
*puiSignalSlaveCount_p,
WORD * pwFlags_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
@ -1347,7 +1342,7 @@ Exit:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplNmtMnuCbNmtRequest(tEplFrameInfo * pFrameInfo_p) static tEplKernel EplNmtMnuCbNmtRequest(tEplFrameInfo *pFrameInfo_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
@ -1371,9 +1366,8 @@ static tEplKernel PUBLIC EplNmtMnuCbNmtRequest(tEplFrameInfo * pFrameInfo_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplNmtMnuCbIdentResponse(unsigned int uiNodeId_p, static tEplKernel EplNmtMnuCbIdentResponse(unsigned int uiNodeId_p,
tEplIdentResponse * tEplIdentResponse *pIdentResponse_p)
pIdentResponse_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
@ -1431,9 +1425,8 @@ static tEplKernel PUBLIC EplNmtMnuCbIdentResponse(unsigned int uiNodeId_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplNmtMnuCbStatusResponse(unsigned int uiNodeId_p, static tEplKernel EplNmtMnuCbStatusResponse(unsigned int uiNodeId_p,
tEplStatusResponse * tEplStatusResponse *pStatusResponse_p)
pStatusResponse_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;

16
drivers/staging/epl/EplNmtk.c
View File

@ -88,8 +88,8 @@
// TracePoint support for realtime-debugging // TracePoint support for realtime-debugging
#ifdef _DBG_TRACE_POINTS_ #ifdef _DBG_TRACE_POINTS_
void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p); void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p); void TgtDbgPostTraceValue(DWORD dwTraceValue_p);
#define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p) #define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p)
#define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v) #define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v)
#else #else
@ -163,7 +163,7 @@ EPL_MCO_DEFINE_INSTANCE_FCT()
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplNmtkInit(EPL_MCO_DECL_PTR_INSTANCE_PTR) EPLDLLEXPORT tEplKernel EplNmtkInit(EPL_MCO_DECL_PTR_INSTANCE_PTR)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -189,7 +189,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtkInit(EPL_MCO_DECL_PTR_INSTANCE_PTR)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplNmtkAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR) EPLDLLEXPORT tEplKernel EplNmtkAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR)
{ {
EPL_MCO_DECL_INSTANCE_PTR_LOCAL tEplKernel Ret; EPL_MCO_DECL_INSTANCE_PTR_LOCAL tEplKernel Ret;
//tEplEvent Event; //tEplEvent Event;
@ -258,7 +258,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtkAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if (EPL_USE_DELETEINST_FUNC != FALSE) #if (EPL_USE_DELETEINST_FUNC != FALSE)
EPLDLLEXPORT tEplKernel PUBLIC EplNmtkDelInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR) EPLDLLEXPORT tEplKernel EplNmtkDelInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
// check for all API function if instance is valid // check for all API function if instance is valid
@ -296,8 +296,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtkDelInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplNmtkProcess(EPL_MCO_DECL_PTR_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplNmtkProcess(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplEvent *pEvent_p)
tEplEvent * pEvent_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplNmtState OldNmtState; tEplNmtState OldNmtState;
@ -1804,8 +1803,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtkProcess(EPL_MCO_DECL_PTR_INSTANCE_PTR_
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplNmtState PUBLIC EPLDLLEXPORT tEplNmtState EplNmtkGetNmtState(EPL_MCO_DECL_PTR_INSTANCE_PTR)
EplNmtkGetNmtState(EPL_MCO_DECL_PTR_INSTANCE_PTR)
{ {
tEplNmtState NmtState; tEplNmtState NmtState;

16
drivers/staging/epl/EplNmtu.c
View File

@ -132,7 +132,7 @@ static tEplNmtuInstance EplNmtuInstance_g;
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplNmtuInit() EPLDLLEXPORT tEplKernel EplNmtuInit(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -158,7 +158,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtuInit()
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplNmtuAddInstance() EPLDLLEXPORT tEplKernel EplNmtuAddInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -187,7 +187,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtuAddInstance()
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplNmtuDelInstance() EPLDLLEXPORT tEplKernel EplNmtuDelInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -219,7 +219,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtuDelInstance()
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplNmtuNmtEvent(tEplNmtEvent NmtEvent_p) EPLDLLEXPORT tEplKernel EplNmtuNmtEvent(tEplNmtEvent NmtEvent_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplEvent Event; tEplEvent Event;
@ -253,7 +253,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtuNmtEvent(tEplNmtEvent NmtEvent_p)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplNmtState PUBLIC EplNmtuGetNmtState() EPLDLLEXPORT tEplNmtState EplNmtuGetNmtState(void)
{ {
tEplNmtState NmtState; tEplNmtState NmtState;
@ -284,7 +284,7 @@ EPLDLLEXPORT tEplNmtState PUBLIC EplNmtuGetNmtState()
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplNmtuProcessEvent(tEplEvent * pEplEvent_p) EPLDLLEXPORT tEplKernel EplNmtuProcessEvent(tEplEvent *pEplEvent_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -664,9 +664,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtuProcessEvent(tEplEvent * pEplEvent_p)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EPLDLLEXPORT tEplKernel EplNmtuRegisterStateChangeCb(tEplNmtuStateChangeCallback pfnEplNmtStateChangeCb_p)
EplNmtuRegisterStateChangeCb(tEplNmtuStateChangeCallback
pfnEplNmtStateChangeCb_p)
{ {
tEplKernel Ret; tEplKernel Ret;

2
drivers/staging/epl/EplNmtuCal.c
View File

@ -119,7 +119,7 @@
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplNmtState PUBLIC EplNmtkCalGetNmtState() EPLDLLEXPORT tEplNmtState EplNmtkCalGetNmtState(void)
{ {
tEplNmtState NmtState; tEplNmtState NmtState;
// for test direkt call for EplNmtkGetNmtState() // for test direkt call for EplNmtkGetNmtState()

168
drivers/staging/epl/EplObd.c
View File

@ -189,24 +189,22 @@ void *EplObdGetObjectDataPtrIntern(tEplObdSubEntryPtr pSubindexEntry_p);
static tEplKernel EplObdIsNumericalIntern(tEplObdSubEntryPtr pObdSubEntry_p, static tEplKernel EplObdIsNumericalIntern(tEplObdSubEntryPtr pObdSubEntry_p,
BOOL * pfEntryNumerical_p); BOOL * pfEntryNumerical_p);
static tEplKernel PUBLIC EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_ static tEplKernel EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiIndex_p, unsigned int uiSubIndex_p,
unsigned int uiSubIndex_p, void *pSrcData_p,
void *pSrcData_p, void **ppDstData_p,
void **ppDstData_p, tEplObdSize Size_p,
tEplObdSize Size_p, tEplObdEntryPtr *ppObdEntry_p,
tEplObdEntryPtr * ppObdEntry_p, tEplObdSubEntryPtr *ppSubEntry_p,
tEplObdSubEntryPtr * ppSubEntry_p, tEplObdCbParam MEM *pCbParam_p,
tEplObdCbParam MEM * pCbParam_p, tEplObdSize *pObdSize_p);
tEplObdSize * pObdSize_p);
static tEplKernel PUBLIC EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_ static tEplKernel EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPtr pObdEntry_p,
tEplObdEntryPtr pObdEntry_p, tEplObdSubEntryPtr pSubEntry_p,
tEplObdSubEntryPtr pSubEntry_p, tEplObdCbParam MEM *pCbParam_p,
tEplObdCbParam MEM * pCbParam_p, void *pSrcData_p,
void *pSrcData_p, void *pDstData_p,
void *pDstData_p, tEplObdSize ObdSize_p);
tEplObdSize ObdSize_p);
//=========================================================================// //=========================================================================//
// // // //
@ -228,8 +226,7 @@ static tEplKernel PUBLIC EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdInit(EPL_MCO_DECL_PTR_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObdInit(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitParam MEM *pInitParam_p)
tEplObdInitParam MEM * pInitParam_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -261,9 +258,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdInit(EPL_MCO_DECL_PTR_INSTANCE_PTR_
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObdAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitParam MEM *pInitParam_p)
tEplObdInitParam MEM *
pInitParam_p)
{ {
EPL_MCO_DECL_INSTANCE_PTR_LOCAL tEplKernel Ret; EPL_MCO_DECL_INSTANCE_PTR_LOCAL tEplKernel Ret;
@ -308,7 +303,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR_
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if (EPL_USE_DELETEINST_FUNC != FALSE) #if (EPL_USE_DELETEINST_FUNC != FALSE)
EPLDLLEXPORT tEplKernel PUBLIC EplObdDeleteInstance(EPL_MCO_DECL_INSTANCE_PTR) EPLDLLEXPORT tEplKernel EplObdDeleteInstance(EPL_MCO_DECL_INSTANCE_PTR)
{ {
// check for all API function if instance is valid // check for all API function if instance is valid
EPL_MCO_CHECK_INSTANCE_STATE(); EPL_MCO_CHECK_INSTANCE_STATE();
@ -341,11 +336,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdDeleteInstance(EPL_MCO_DECL_INSTANCE_PTR)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdWriteEntry(EPL_MCO_DECL_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObdWriteEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiIndex_p, unsigned int uiSubIndex_p,
unsigned int uiSubIndex_p, void *pSrcData_p,
void *pSrcData_p, tEplObdSize Size_p)
tEplObdSize Size_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -402,11 +396,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdWriteEntry(EPL_MCO_DECL_INSTANCE_PTR_
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdReadEntry(EPL_MCO_DECL_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObdReadEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiIndex_p, unsigned int uiSubIndex_p,
unsigned int uiSubIndex_p, void *pDstData_p,
void *pDstData_p, tEplObdSize *pSize_p)
tEplObdSize * pSize_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -487,9 +480,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdReadEntry(EPL_MCO_DECL_INSTANCE_PTR_
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdAccessOdPart(EPL_MCO_DECL_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObdAccessOdPart(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdPart ObdPart_p,
tEplObdPart ObdPart_p, tEplObdDir Direction_p)
tEplObdDir Direction_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
@ -587,8 +579,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdAccessOdPart(EPL_MCO_DECL_INSTANCE_PTR_
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdDefineVar(EPL_MCO_DECL_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObdDefineVar(EPL_MCO_DECL_INSTANCE_PTR_ tEplVarParam MEM *pVarParam_p)
tEplVarParam MEM * pVarParam_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -674,9 +665,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdDefineVar(EPL_MCO_DECL_INSTANCE_PTR_
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT void *PUBLIC EplObdGetObjectDataPtr(EPL_MCO_DECL_INSTANCE_PTR_ EPLDLLEXPORT void *EplObdGetObjectDataPtr(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiIndex_p, unsigned int uiSubIndex_p)
unsigned int uiSubIndex_p)
{ {
tEplKernel Ret; tEplKernel Ret;
void *pData; void *pData;
@ -719,8 +709,7 @@ EPLDLLEXPORT void *PUBLIC EplObdGetObjectDataPtr(EPL_MCO_DECL_INSTANCE_PTR_
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdRegisterUserOd(EPL_MCO_DECL_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObdRegisterUserOd(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPtr pUserOd_p)
tEplObdEntryPtr pUserOd_p)
{ {
EPL_MCO_CHECK_INSTANCE_STATE(); EPL_MCO_CHECK_INSTANCE_STATE();
@ -749,10 +738,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdRegisterUserOd(EPL_MCO_DECL_INSTANCE_PTR_
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT void PUBLIC EplObdInitVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ EPLDLLEXPORT void EplObdInitVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdVarEntry MEM *pVarEntry_p,
tEplObdVarEntry MEM * pVarEntry_p, tEplObdType Type_p, tEplObdSize ObdSize_p)
tEplObdType Type_p,
tEplObdSize ObdSize_p)
{ {
/* /*
#if (EPL_PDO_USE_STATIC_MAPPING == FALSE) #if (EPL_PDO_USE_STATIC_MAPPING == FALSE)
@ -803,9 +790,8 @@ EPLDLLEXPORT void PUBLIC EplObdInitVarEntry(EPL_MCO_DECL_INSTANCE_PTR_
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplObdSize PUBLIC EplObdGetDataSize(EPL_MCO_DECL_INSTANCE_PTR_ EPLDLLEXPORT tEplObdSize EplObdGetDataSize(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiIndex_p, unsigned int uiSubIndex_p)
unsigned int uiSubIndex_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplObdSize ObdSize; tEplObdSize ObdSize;
@ -845,7 +831,7 @@ EPLDLLEXPORT tEplObdSize PUBLIC EplObdGetDataSize(EPL_MCO_DECL_INSTANCE_PTR_
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT unsigned int PUBLIC EplObdGetNodeId(EPL_MCO_DECL_INSTANCE_PTR) EPLDLLEXPORT unsigned int EplObdGetNodeId(EPL_MCO_DECL_INSTANCE_PTR)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplObdSize ObdSize; tEplObdSize ObdSize;
@ -882,9 +868,8 @@ EPLDLLEXPORT unsigned int PUBLIC EplObdGetNodeId(EPL_MCO_DECL_INSTANCE_PTR)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdSetNodeId(EPL_MCO_DECL_PTR_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObdSetNodeId(EPL_MCO_DECL_PTR_INSTANCE_PTR_ unsigned int uiNodeId_p,
unsigned int uiNodeId_p, tEplObdNodeIdType NodeIdType_p)
tEplObdNodeIdType NodeIdType_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplObdSize ObdSize; tEplObdSize ObdSize;
@ -966,10 +951,9 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdSetNodeId(EPL_MCO_DECL_PTR_INSTANCE_PTR_
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdIsNumerical(EPL_MCO_DECL_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObdIsNumerical(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiIndex_p, unsigned int uiSubIndex_p,
unsigned int uiSubIndex_p, BOOL *pfEntryNumerical_p)
BOOL * pfEntryNumerical_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplObdEntryPtr pObdEntry; tEplObdEntryPtr pObdEntry;
@ -1018,11 +1002,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdIsNumerical(EPL_MCO_DECL_INSTANCE_PTR_
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdReadEntryToLe(EPL_MCO_DECL_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObdReadEntryToLe(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiIndex_p, unsigned int uiSubIndex_p,
unsigned int uiSubIndex_p, void *pDstData_p,
void *pDstData_p, tEplObdSize *pSize_p)
tEplObdSize * pSize_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplObdEntryPtr pObdEntry; tEplObdEntryPtr pObdEntry;
@ -1199,11 +1182,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdReadEntryToLe(EPL_MCO_DECL_INSTANCE_PTR_
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdWriteEntryFromLe(EPL_MCO_DECL_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObdWriteEntryFromLe(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiIndex_p, unsigned int uiSubIndex_p,
unsigned int uiSubIndex_p, void *pSrcData_p,
void *pSrcData_p, tEplObdSize Size_p)
tEplObdSize Size_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplObdEntryPtr pObdEntry; tEplObdEntryPtr pObdEntry;
@ -1345,10 +1327,9 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdWriteEntryFromLe(EPL_MCO_DECL_INSTANCE_PTR_
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdGetAccessType(EPL_MCO_DECL_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObdGetAccessType(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiIndex_p, unsigned int uiSubIndex_p,
unsigned int uiSubIndex_p, tEplObdAccess *pAccessTyp_p)
tEplObdAccess * pAccessTyp_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplObdEntryPtr pObdEntry; tEplObdEntryPtr pObdEntry;
@ -1388,10 +1369,9 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdGetAccessType(EPL_MCO_DECL_INSTANCE_PTR_
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplObdSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ tEplKernel EplObdSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiIndex_p, unsigned int uiSubindex_p,
unsigned int uiSubindex_p, tEplObdVarEntry MEM **ppVarEntry_p)
tEplObdVarEntry MEM ** ppVarEntry_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -1870,16 +1850,15 @@ static tEplKernel EplObdCheckObjectRange(tEplObdSubEntryPtr pSubindexEntry_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_ static tEplKernel EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiIndex_p, unsigned int uiSubIndex_p,
unsigned int uiSubIndex_p, void *pSrcData_p,
void *pSrcData_p, void **ppDstData_p,
void **ppDstData_p, tEplObdSize Size_p,
tEplObdSize Size_p, tEplObdEntryPtr *ppObdEntry_p,
tEplObdEntryPtr * ppObdEntry_p, tEplObdSubEntryPtr *ppSubEntry_p,
tEplObdSubEntryPtr * ppSubEntry_p, tEplObdCbParam MEM *pCbParam_p,
tEplObdCbParam MEM * pCbParam_p, tEplObdSize *pObdSize_p)
tEplObdSize * pObdSize_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -2064,13 +2043,12 @@ static tEplKernel PUBLIC EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_ static tEplKernel EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPtr pObdEntry_p,
tEplObdEntryPtr pObdEntry_p, tEplObdSubEntryPtr pSubEntry_p,
tEplObdSubEntryPtr pSubEntry_p, tEplObdCbParam MEM *pCbParam_p,
tEplObdCbParam MEM * pCbParam_p, void *pSrcData_p,
void *pSrcData_p, void *pDstData_p,
void *pDstData_p, tEplObdSize ObdSize_p)
tEplObdSize ObdSize_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -2762,9 +2740,7 @@ static tEplKernel EplObdGetSubindexIntern(tEplObdEntryPtr pObdEntry_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if (EPL_OBD_USE_STORE_RESTORE != FALSE) #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
EPLDLLEXPORT tEplKernel PUBLIC EPLDLLEXPORT tEplKernel EplObdSetStoreLoadObjCallback(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdStoreLoadObjCallback fpCallback_p)
EplObdSetStoreLoadObjCallback(EPL_MCO_DECL_INSTANCE_PTR_
tEplObdStoreLoadObjCallback fpCallback_p)
{ {
EPL_MCO_CHECK_INSTANCE_STATE(); EPL_MCO_CHECK_INSTANCE_STATE();

17
drivers/staging/epl/EplObd.h
View File

@ -283,8 +283,7 @@ typedef enum {
kVarValidAll = 0x03 // currently only size and data are implemented and used kVarValidAll = 0x03 // currently only size and data are implemented and used
} tEplVarParamValid; } tEplVarParamValid;
typedef tEplKernel(PUBLIC ROM * tEplVarCallback) (CCM_DECL_INSTANCE_HDL_ typedef tEplKernel(ROM *tEplVarCallback) (CCM_DECL_INSTANCE_HDL_ void *pParam_p);
void *pParam_p);
typedef struct { typedef struct {
tEplVarParamValid m_ValidFlag; tEplVarParamValid m_ValidFlag;
@ -376,9 +375,7 @@ typedef struct {
} tEplObdCbParam; } tEplObdCbParam;
// define type for callback function: pParam_p points to tEplObdCbParam // define type for callback function: pParam_p points to tEplObdCbParam
typedef tEplKernel(PUBLIC ROM * tEplObdCallback) (CCM_DECL_INSTANCE_HDL_ typedef tEplKernel(ROM *tEplObdCallback) (CCM_DECL_INSTANCE_HDL_ tEplObdCbParam MEM * pParam_p);
tEplObdCbParam MEM *
pParam_p);
// do not change the order for this struct!!! // do not change the order for this struct!!!
@ -422,14 +419,10 @@ typedef struct {
} tEplObdCbStoreParam; } tEplObdCbStoreParam;
typedef tEplKernel(PUBLIC ROM * tInitTabEntryCallback) (void MEM * pTabEntry_p, typedef tEplKernel(ROM *tInitTabEntryCallback) (void MEM * pTabEntry_p,
unsigned int unsigned int uiObjIndex_p);
uiObjIndex_p);
typedef tEplKernel(PUBLIC ROM * typedef tEplKernel(ROM * tEplObdStoreLoadObjCallback) (CCM_DECL_INSTANCE_HDL_ tEplObdCbStoreParam MEM *pCbStoreParam_p);
tEplObdStoreLoadObjCallback) (CCM_DECL_INSTANCE_HDL_
tEplObdCbStoreParam MEM *
pCbStoreParam_p);
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
// this stucture is used for parameters for function ObdInitModuleTab() // this stucture is used for parameters for function ObdInitModuleTab()

74
drivers/staging/epl/EplObdu.c
View File

@ -121,10 +121,9 @@
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduWriteEntry(unsigned int uiIndex_p, EPLDLLEXPORT tEplKernel EplObduWriteEntry(unsigned int uiIndex_p,
unsigned int uiSubIndex_p, unsigned int uiSubIndex_p,
void *pSrcData_p, void *pSrcData_p, tEplObdSize Size_p)
tEplObdSize Size_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -153,10 +152,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduWriteEntry(unsigned int uiIndex_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduReadEntry(unsigned int uiIndex_p, EPLDLLEXPORT tEplKernel EplObduReadEntry(unsigned int uiIndex_p,
unsigned int uiSubIndex_p, unsigned int uiSubIndex_p,
void *pDstData_p, void *pDstData_p,
tEplObdSize * pSize_p) tEplObdSize *pSize_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -179,8 +178,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduReadEntry(unsigned int uiIndex_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduAccessOdPart(tEplObdPart ObdPart_p, EPLDLLEXPORT tEplKernel EplObduAccessOdPart(tEplObdPart ObdPart_p,
tEplObdDir Direction_p) tEplObdDir Direction_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -202,7 +201,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduAccessOdPart(tEplObdPart ObdPart_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduDefineVar(tEplVarParam MEM * pVarParam_p) EPLDLLEXPORT tEplKernel EplObduDefineVar(tEplVarParam MEM *pVarParam_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -226,8 +225,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduDefineVar(tEplVarParam MEM * pVarParam_p)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT void *PUBLIC EplObduGetObjectDataPtr(unsigned int uiIndex_p, EPLDLLEXPORT void *EplObduGetObjectDataPtr(unsigned int uiIndex_p,
unsigned int uiSubIndex_p) unsigned int uiSubIndex_p)
{ {
void *pData; void *pData;
@ -250,7 +249,7 @@ EPLDLLEXPORT void *PUBLIC EplObduGetObjectDataPtr(unsigned int uiIndex_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE)) #if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
EPLDLLEXPORT tEplKernel PUBLIC EplObduRegisterUserOd(tEplObdEntryPtr pUserOd_p) EPLDLLEXPORT tEplKernel EplObduRegisterUserOd(tEplObdEntryPtr pUserOd_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -275,9 +274,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduRegisterUserOd(tEplObdEntryPtr pUserOd_p)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT void PUBLIC EplObduInitVarEntry(tEplObdVarEntry MEM * pVarEntry_p, EPLDLLEXPORT void EplObduInitVarEntry(tEplObdVarEntry MEM *pVarEntry_p,
BYTE bType_p, BYTE bType_p, tEplObdSize ObdSize_p)
tEplObdSize ObdSize_p)
{ {
EplObduCalInitVarEntry(pVarEntry_p, bType_p, ObdSize_p); EplObduCalInitVarEntry(pVarEntry_p, bType_p, ObdSize_p);
} }
@ -299,8 +297,8 @@ EPLDLLEXPORT void PUBLIC EplObduInitVarEntry(tEplObdVarEntry MEM * pVarEntry_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplObdSize PUBLIC EplObduGetDataSize(unsigned int uiIndex_p, EPLDLLEXPORT tEplObdSize EplObduGetDataSize(unsigned int uiIndex_p,
unsigned int uiSubIndex_p) unsigned int uiSubIndex_p)
{ {
tEplObdSize Size; tEplObdSize Size;
@ -323,7 +321,7 @@ EPLDLLEXPORT tEplObdSize PUBLIC EplObduGetDataSize(unsigned int uiIndex_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT unsigned int PUBLIC EplObduGetNodeId() EPLDLLEXPORT unsigned int EplObduGetNodeId(void)
{ {
unsigned int uiNodeId; unsigned int uiNodeId;
@ -347,8 +345,8 @@ EPLDLLEXPORT unsigned int PUBLIC EplObduGetNodeId()
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduSetNodeId(unsigned int uiNodeId_p, EPLDLLEXPORT tEplKernel EplObduSetNodeId(unsigned int uiNodeId_p,
tEplObdNodeIdType NodeIdType_p) tEplObdNodeIdType NodeIdType_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -373,10 +371,9 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduSetNodeId(unsigned int uiNodeId_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduGetAccessType(unsigned int uiIndex_p, EPLDLLEXPORT tEplKernel EplObduGetAccessType(unsigned int uiIndex_p,
unsigned int uiSubIndex_p, unsigned int uiSubIndex_p,
tEplObdAccess * tEplObdAccess *pAccessTyp_p)
pAccessTyp_p)
{ {
tEplObdAccess AccessType; tEplObdAccess AccessType;
@ -410,10 +407,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduGetAccessType(unsigned int uiIndex_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduReadEntryToLe(unsigned int uiIndex_p, EPLDLLEXPORT tEplKernel EplObduReadEntryToLe(unsigned int uiIndex_p,
unsigned int uiSubIndex_p, unsigned int uiSubIndex_p,
void *pDstData_p, void *pDstData_p,
tEplObdSize * pSize_p) tEplObdSize *pSize_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -445,11 +442,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduReadEntryToLe(unsigned int uiIndex_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduWriteEntryFromLe(unsigned int uiIndex_p, EPLDLLEXPORT tEplKernel EplObduWriteEntryFromLe(unsigned int uiIndex_p,
unsigned int unsigned int uiSubIndex_p,
uiSubIndex_p, void *pSrcData_p,
void *pSrcData_p, tEplObdSize Size_p)
tEplObdSize Size_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -475,11 +471,9 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduWriteEntryFromLe(unsigned int uiIndex_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObduSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiIndex_p, unsigned int uiSubindex_p,
unsigned int uiSubindex_p, tEplObdVarEntry MEM **ppVarEntry_p)
tEplObdVarEntry MEM **
ppVarEntry_p)
{ {
tEplKernel Ret; tEplKernel Ret;

80
drivers/staging/epl/EplObduCal.c
View File

@ -121,10 +121,10 @@
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduCalWriteEntry(unsigned int uiIndex_p, EPLDLLEXPORT tEplKernel EplObduCalWriteEntry(unsigned int uiIndex_p,
unsigned int uiSubIndex_p, unsigned int uiSubIndex_p,
void *pSrcData_p, void *pSrcData_p,
tEplObdSize Size_p) tEplObdSize Size_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -155,10 +155,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduCalWriteEntry(unsigned int uiIndex_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduCalReadEntry(unsigned int uiIndex_p, EPLDLLEXPORT tEplKernel EplObduCalReadEntry(unsigned int uiIndex_p,
unsigned int uiSubIndex_p, unsigned int uiSubIndex_p,
void *pDstData_p, void *pDstData_p,
tEplObdSize * pSize_p) tEplObdSize *pSize_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -185,8 +185,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduCalReadEntry(unsigned int uiIndex_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduCalAccessOdPart(tEplObdPart ObdPart_p, EPLDLLEXPORT tEplKernel EplObduCalAccessOdPart(tEplObdPart ObdPart_p,
tEplObdDir Direction_p) tEplObdDir Direction_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -212,8 +212,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduCalAccessOdPart(tEplObdPart ObdPart_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduCalDefineVar(tEplVarParam MEM * EPLDLLEXPORT tEplKernel EplObduCalDefineVar(tEplVarParam MEM *pVarParam_p)
pVarParam_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -240,8 +239,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduCalDefineVar(tEplVarParam MEM *
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT void *PUBLIC EplObduCalGetObjectDataPtr(unsigned int uiIndex_p, EPLDLLEXPORT void *EplObduCalGetObjectDataPtr(unsigned int uiIndex_p,
unsigned int uiSubIndex_p) unsigned int uiSubIndex_p)
{ {
void *pData; void *pData;
@ -268,8 +267,7 @@ EPLDLLEXPORT void *PUBLIC EplObduCalGetObjectDataPtr(unsigned int uiIndex_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE)) #if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
EPLDLLEXPORT tEplKernel PUBLIC EplObduCalRegisterUserOd(tEplObdEntryPtr EPLDLLEXPORT tEplKernel EplObduCalRegisterUserOd(tEplObdEntryPtr pUserOd_p)
pUserOd_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -298,9 +296,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduCalRegisterUserOd(tEplObdEntryPtr
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT void PUBLIC EplObduCalInitVarEntry(tEplObdVarEntry MEM * EPLDLLEXPORT void EplObduCalInitVarEntry(tEplObdVarEntry MEM *pVarEntry_p,
pVarEntry_p, BYTE bType_p, BYTE bType_p, tEplObdSize ObdSize_p)
tEplObdSize ObdSize_p)
{ {
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0) #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
EplObdInitVarEntry(pVarEntry_p, bType_p, ObdSize_p); EplObdInitVarEntry(pVarEntry_p, bType_p, ObdSize_p);
@ -324,8 +321,8 @@ EPLDLLEXPORT void PUBLIC EplObduCalInitVarEntry(tEplObdVarEntry MEM *
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplObdSize PUBLIC EplObduCalGetDataSize(unsigned int uiIndex_p, EPLDLLEXPORT tEplObdSize EplObduCalGetDataSize(unsigned int uiIndex_p,
unsigned int uiSubIndex_p) unsigned int uiSubIndex_p)
{ {
tEplObdSize Size; tEplObdSize Size;
@ -352,7 +349,7 @@ EPLDLLEXPORT tEplObdSize PUBLIC EplObduCalGetDataSize(unsigned int uiIndex_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT unsigned int PUBLIC EplObduCalGetNodeId() EPLDLLEXPORT unsigned int EplObduCalGetNodeId(void)
{ {
unsigned int uiNodeId; unsigned int uiNodeId;
@ -380,9 +377,8 @@ EPLDLLEXPORT unsigned int PUBLIC EplObduCalGetNodeId()
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduCalSetNodeId(unsigned int uiNodeId_p, EPLDLLEXPORT tEplKernel EplObduCalSetNodeId(unsigned int uiNodeId_p,
tEplObdNodeIdType tEplObdNodeIdType NodeIdType_p)
NodeIdType_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -411,11 +407,9 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduCalSetNodeId(unsigned int uiNodeId_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduCalGetAccessType(unsigned int uiIndex_p, EPLDLLEXPORT tEplKernel EplObduCalGetAccessType(unsigned int uiIndex_p,
unsigned int unsigned int uiSubIndex_p,
uiSubIndex_p, tEplObdAccess *pAccessTyp_p)
tEplObdAccess *
pAccessTyp_p)
{ {
tEplObdAccess AccesType; tEplObdAccess AccesType;
@ -447,11 +441,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduCalGetAccessType(unsigned int uiIndex_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduCalReadEntryToLe(unsigned int uiIndex_p, EPLDLLEXPORT tEplKernel EplObduCalReadEntryToLe(unsigned int uiIndex_p,
unsigned int unsigned int uiSubIndex_p,
uiSubIndex_p, void *pDstData_p,
void *pDstData_p, tEplObdSize *pSize_p)
tEplObdSize * pSize_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -481,12 +474,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduCalReadEntryToLe(unsigned int uiIndex_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduCalWriteEntryFromLe(unsigned int EPLDLLEXPORT tEplKernel EplObduCalWriteEntryFromLe(unsigned int uiIndex_p,
uiIndex_p, unsigned int uiSubIndex_p,
unsigned int void *pSrcData_p,
uiSubIndex_p, tEplObdSize Size_p)
void *pSrcData_p,
tEplObdSize Size_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -514,10 +505,9 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduCalWriteEntryFromLe(unsigned int
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EPLDLLEXPORT tEplKernel EplObduCalSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
EplObduCalSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p, unsigned int uiSubindex_p,
unsigned int uiSubindex_p, tEplObdVarEntry MEM **ppVarEntry_p)
tEplObdVarEntry MEM ** ppVarEntry_p)
{ {
tEplKernel Ret; tEplKernel Ret;

3
drivers/staging/epl/EplObjDef.h
View File

@ -165,8 +165,7 @@
// //
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EPL_OBD_INIT_RAM_NAME(tEplObdInitParam MEM * EPLDLLEXPORT tEplKernel EPL_OBD_INIT_RAM_NAME(tEplObdInitParam MEM *pInitParam_p)
pInitParam_p)
{ {
tEplObdInitParam MEM *pInitParam = pInitParam_p; tEplObdInitParam MEM *pInitParam = pInitParam_p;

2
drivers/staging/epl/EplPdou.c
View File

@ -226,7 +226,7 @@ tEplKernel EplPdouDelInstance(void)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplPdouCbObdAccess(tEplObdCbParam MEM * pParam_p) tEplKernel EplPdouCbObdAccess(tEplObdCbParam MEM *pParam_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
unsigned int uiPdoId; unsigned int uiPdoId;

22
drivers/staging/epl/EplSdo.h
View File

@ -116,20 +116,18 @@ typedef unsigned int tEplSdoConHdl;
// callback function pointer for Protocol Abstraction Layer to call // callback function pointer for Protocol Abstraction Layer to call
// asynchronuus SDO Sequence Layer // asynchronuus SDO Sequence Layer
typedef tEplKernel(PUBLIC * tEplSequLayerReceiveCb) (tEplSdoConHdl ConHdl_p, typedef tEplKernel(*tEplSequLayerReceiveCb) (tEplSdoConHdl ConHdl_p,
tEplAsySdoSeq * tEplAsySdoSeq *pSdoSeqData_p,
pSdoSeqData_p, unsigned int uiDataSize_p);
unsigned int uiDataSize_p);
// handle between asynchronuus SDO Sequence Layer and SDO Command layer // handle between asynchronuus SDO Sequence Layer and SDO Command layer
typedef unsigned int tEplSdoSeqConHdl; typedef unsigned int tEplSdoSeqConHdl;
// callback function pointer for asynchronuus SDO Sequence Layer to call // callback function pointer for asynchronuus SDO Sequence Layer to call
// SDO Command layer for received data // SDO Command layer for received data
typedef tEplKernel(PUBLIC * typedef tEplKernel(* tEplSdoComReceiveCb) (tEplSdoSeqConHdl SdoSeqConHdl_p,
tEplSdoComReceiveCb) (tEplSdoSeqConHdl SdoSeqConHdl_p, tEplAsySdoCom *pAsySdoCom_p,
tEplAsySdoCom * pAsySdoCom_p, unsigned int uiDataSize_p);
unsigned int uiDataSize_p);
// status of connection // status of connection
typedef enum { typedef enum {
@ -143,9 +141,8 @@ typedef enum {
// callback function pointer for asynchronuus SDO Sequence Layer to call // callback function pointer for asynchronuus SDO Sequence Layer to call
// SDO Command layer for connection status // SDO Command layer for connection status
typedef tEplKernel(PUBLIC * tEplSdoComConCb) (tEplSdoSeqConHdl SdoSeqConHdl_p, typedef tEplKernel(* tEplSdoComConCb) (tEplSdoSeqConHdl SdoSeqConHdl_p,
tEplAsySdoConState tEplAsySdoConState AsySdoConState_p);
AsySdoConState_p);
// handle between SDO Command layer and application // handle between SDO Command layer and application
typedef unsigned int tEplSdoComConHdl; typedef unsigned int tEplSdoComConHdl;
@ -221,8 +218,7 @@ typedef struct {
} tEplSdoComFinished; } tEplSdoComFinished;
// callback function pointer to inform application about connection // callback function pointer to inform application about connection
typedef tEplKernel(PUBLIC * tEplSdoFinishedCb) (tEplSdoComFinished * typedef tEplKernel(* tEplSdoFinishedCb) (tEplSdoComFinished *pSdoComFinished_p);
pSdoComFinished_p);
// structure to init SDO transfer to Read or Write by Index // structure to init SDO transfer to Read or Write by Index
typedef struct { typedef struct {

22
drivers/staging/epl/EplSdoAsndu.c
View File

@ -110,7 +110,7 @@ static tEplSdoAsndInstance SdoAsndInstance_g;
// local function prototypes // local function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoAsnduCb(tEplFrameInfo * pFrameInfo_p); tEplKernel EplSdoAsnduCb(tEplFrameInfo *pFrameInfo_p);
/***************************************************************************/ /***************************************************************************/
/* */ /* */
@ -149,7 +149,7 @@ tEplKernel PUBLIC EplSdoAsnduCb(tEplFrameInfo * pFrameInfo_p);
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoAsnduInit(tEplSequLayerReceiveCb fpReceiveCb_p) tEplKernel EplSdoAsnduInit(tEplSequLayerReceiveCb fpReceiveCb_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -176,7 +176,7 @@ tEplKernel PUBLIC EplSdoAsnduInit(tEplSequLayerReceiveCb fpReceiveCb_p)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoAsnduAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p) tEplKernel EplSdoAsnduAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -218,7 +218,7 @@ tEplKernel PUBLIC EplSdoAsnduAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoAsnduDelInstance() tEplKernel EplSdoAsnduDelInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -251,8 +251,8 @@ tEplKernel PUBLIC EplSdoAsnduDelInstance()
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoAsnduInitCon(tEplSdoConHdl * pSdoConHandle_p, tEplKernel EplSdoAsnduInitCon(tEplSdoConHdl *pSdoConHandle_p,
unsigned int uiTargetNodeId_p) unsigned int uiTargetNodeId_p)
{ {
tEplKernel Ret; tEplKernel Ret;
unsigned int uiCount; unsigned int uiCount;
@ -319,9 +319,9 @@ tEplKernel PUBLIC EplSdoAsnduInitCon(tEplSdoConHdl * pSdoConHandle_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoAsnduSendData(tEplSdoConHdl SdoConHandle_p, tEplKernel EplSdoAsnduSendData(tEplSdoConHdl SdoConHandle_p,
tEplFrame * pSrcData_p, tEplFrame *pSrcData_p,
DWORD dwDataSize_p) DWORD dwDataSize_p)
{ {
tEplKernel Ret; tEplKernel Ret;
unsigned int uiArray; unsigned int uiArray;
@ -379,7 +379,7 @@ tEplKernel PUBLIC EplSdoAsnduSendData(tEplSdoConHdl SdoConHandle_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoAsnduDelCon(tEplSdoConHdl SdoConHandle_p) tEplKernel EplSdoAsnduDelCon(tEplSdoConHdl SdoConHandle_p)
{ {
tEplKernel Ret; tEplKernel Ret;
unsigned int uiArray; unsigned int uiArray;
@ -422,7 +422,7 @@ tEplKernel PUBLIC EplSdoAsnduDelCon(tEplSdoConHdl SdoConHandle_p)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoAsnduCb(tEplFrameInfo * pFrameInfo_p) tEplKernel EplSdoAsnduCb(tEplFrameInfo *pFrameInfo_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
unsigned int uiCount; unsigned int uiCount;

38
drivers/staging/epl/EplSdoAsySequ.c
View File

@ -203,9 +203,9 @@ static tEplKernel EplSdoAsySeqSendLowerLayer(tEplAsySdoSeqCon * pAsySdoSeqCon_p,
unsigned int uiDataSize_p, unsigned int uiDataSize_p,
tEplFrame * pEplFrame_p); tEplFrame * pEplFrame_p);
tEplKernel PUBLIC EplSdoAsyReceiveCb(tEplSdoConHdl ConHdl_p, tEplKernel EplSdoAsyReceiveCb(tEplSdoConHdl ConHdl_p,
tEplAsySdoSeq * pSdoSeqData_p, tEplAsySdoSeq *pSdoSeqData_p,
unsigned int uiDataSize_p); unsigned int uiDataSize_p);
static tEplKernel EplSdoAsyInitHistory(void); static tEplKernel EplSdoAsyInitHistory(void);
@ -267,8 +267,8 @@ static tEplKernel EplSdoAsySeqSetTimer(tEplAsySdoSeqCon * pAsySdoSeqCon_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoAsySeqInit(tEplSdoComReceiveCb fpSdoComCb_p, tEplKernel EplSdoAsySeqInit(tEplSdoComReceiveCb fpSdoComCb_p,
tEplSdoComConCb fpSdoComConCb_p) tEplSdoComConCb fpSdoComConCb_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -297,8 +297,8 @@ tEplKernel PUBLIC EplSdoAsySeqInit(tEplSdoComReceiveCb fpSdoComCb_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoAsySeqAddInstance(tEplSdoComReceiveCb fpSdoComCb_p, tEplKernel EplSdoAsySeqAddInstance(tEplSdoComReceiveCb fpSdoComCb_p,
tEplSdoComConCb fpSdoComConCb_p) tEplSdoComConCb fpSdoComConCb_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -380,7 +380,7 @@ tEplKernel PUBLIC EplSdoAsySeqAddInstance(tEplSdoComReceiveCb fpSdoComCb_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoAsySeqDelInstance() tEplKernel EplSdoAsySeqDelInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
unsigned int uiCount; unsigned int uiCount;
@ -439,9 +439,9 @@ tEplKernel PUBLIC EplSdoAsySeqDelInstance()
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoAsySeqInitCon(tEplSdoSeqConHdl * pSdoSeqConHdl_p, tEplKernel EplSdoAsySeqInitCon(tEplSdoSeqConHdl *pSdoSeqConHdl_p,
unsigned int uiNodeId_p, unsigned int uiNodeId_p,
tEplSdoType SdoType) tEplSdoType SdoType)
{ {
tEplKernel Ret; tEplKernel Ret;
unsigned int uiCount; unsigned int uiCount;
@ -594,9 +594,9 @@ tEplKernel PUBLIC EplSdoAsySeqInitCon(tEplSdoSeqConHdl * pSdoSeqConHdl_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoAsySeqSendData(tEplSdoSeqConHdl SdoSeqConHdl_p, tEplKernel EplSdoAsySeqSendData(tEplSdoSeqConHdl SdoSeqConHdl_p,
unsigned int uiDataSize_p, unsigned int uiDataSize_p,
tEplFrame * pabData_p) tEplFrame *pabData_p)
{ {
tEplKernel Ret; tEplKernel Ret;
unsigned int uiHandle; unsigned int uiHandle;
@ -640,7 +640,7 @@ tEplKernel PUBLIC EplSdoAsySeqSendData(tEplSdoSeqConHdl SdoSeqConHdl_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoAsySeqProcessEvent(tEplEvent * pEvent_p) tEplKernel EplSdoAsySeqProcessEvent(tEplEvent *pEvent_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplTimerEventArg *pTimerEventArg; tEplTimerEventArg *pTimerEventArg;
@ -714,7 +714,7 @@ tEplKernel PUBLIC EplSdoAsySeqProcessEvent(tEplEvent * pEvent_p)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoAsySeqDelCon(tEplSdoSeqConHdl SdoSeqConHdl_p) tEplKernel EplSdoAsySeqDelCon(tEplSdoSeqConHdl SdoSeqConHdl_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
unsigned int uiHandle; unsigned int uiHandle;
@ -2139,9 +2139,9 @@ static tEplKernel EplSdoAsySeqSendLowerLayer(tEplAsySdoSeqCon * pAsySdoSeqCon_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoAsyReceiveCb(tEplSdoConHdl ConHdl_p, tEplKernel EplSdoAsyReceiveCb(tEplSdoConHdl ConHdl_p,
tEplAsySdoSeq * pSdoSeqData_p, tEplAsySdoSeq *pSdoSeqData_p,
unsigned int uiDataSize_p) unsigned int uiDataSize_p)
{ {
tEplKernel Ret; tEplKernel Ret;
unsigned int uiCount = 0; unsigned int uiCount = 0;

45
drivers/staging/epl/EplSdoComu.c
View File

@ -205,12 +205,12 @@ static tEplSdoComInstance SdoComInstance_g;
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// local function prototypes // local function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoComReceiveCb(tEplSdoSeqConHdl SdoSeqConHdl_p, tEplKernel EplSdoComReceiveCb(tEplSdoSeqConHdl SdoSeqConHdl_p,
tEplAsySdoCom * pAsySdoCom_p, tEplAsySdoCom *pAsySdoCom_p,
unsigned int uiDataSize_p); unsigned int uiDataSize_p);
tEplKernel PUBLIC EplSdoComConCb(tEplSdoSeqConHdl SdoSeqConHdl_p, tEplKernel EplSdoComConCb(tEplSdoSeqConHdl SdoSeqConHdl_p,
tEplAsySdoConState AsySdoConState_p); tEplAsySdoConState AsySdoConState_p);
static tEplKernel EplSdoComSearchConIntern(tEplSdoSeqConHdl SdoSeqConHdl_p, static tEplKernel EplSdoComSearchConIntern(tEplSdoSeqConHdl SdoSeqConHdl_p,
tEplSdoComConEvent SdoComConEvent_p, tEplSdoComConEvent SdoComConEvent_p,
@ -285,7 +285,7 @@ static tEplKernel EplSdoComClientSendAbort(tEplSdoComCon * pSdoComCon_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoComInit(void) tEplKernel EplSdoComInit(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -312,7 +312,7 @@ tEplKernel PUBLIC EplSdoComInit(void)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoComAddInstance(void) tEplKernel EplSdoComAddInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -354,7 +354,7 @@ tEplKernel PUBLIC EplSdoComAddInstance(void)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoComDelInstance(void) tEplKernel EplSdoComDelInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -398,9 +398,9 @@ tEplKernel PUBLIC EplSdoComDelInstance(void)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0) #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
tEplKernel PUBLIC EplSdoComDefineCon(tEplSdoComConHdl * pSdoComConHdl_p, tEplKernel EplSdoComDefineCon(tEplSdoComConHdl *pSdoComConHdl_p,
unsigned int uiTargetNodeId_p, unsigned int uiTargetNodeId_p,
tEplSdoType ProtType_p) tEplSdoType ProtType_p)
{ {
tEplKernel Ret; tEplKernel Ret;
unsigned int uiCount; unsigned int uiCount;
@ -511,8 +511,7 @@ tEplKernel PUBLIC EplSdoComDefineCon(tEplSdoComConHdl * pSdoComConHdl_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0) #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
tEplKernel PUBLIC EplSdoComInitTransferByIndex(tEplSdoComTransParamByIndex * tEplKernel EplSdoComInitTransferByIndex(tEplSdoComTransParamByIndex *pSdoComTransParam_p)
pSdoComTransParam_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplSdoComCon *pSdoComCon; tEplSdoComCon *pSdoComCon;
@ -603,7 +602,7 @@ tEplKernel PUBLIC EplSdoComInitTransferByIndex(tEplSdoComTransParamByIndex *
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0) #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
tEplKernel PUBLIC EplSdoComUndefineCon(tEplSdoComConHdl SdoComConHdl_p) tEplKernel EplSdoComUndefineCon(tEplSdoComConHdl SdoComConHdl_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplSdoComCon *pSdoComCon; tEplSdoComCon *pSdoComCon;
@ -669,8 +668,8 @@ tEplKernel PUBLIC EplSdoComUndefineCon(tEplSdoComConHdl SdoComConHdl_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0) #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
tEplKernel PUBLIC EplSdoComGetState(tEplSdoComConHdl SdoComConHdl_p, tEplKernel EplSdoComGetState(tEplSdoComConHdl SdoComConHdl_p,
tEplSdoComFinished * pSdoComFinished_p) tEplSdoComFinished *pSdoComFinished_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplSdoComCon *pSdoComCon; tEplSdoComCon *pSdoComCon;
@ -747,8 +746,8 @@ tEplKernel PUBLIC EplSdoComGetState(tEplSdoComConHdl SdoComConHdl_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0) #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
tEplKernel PUBLIC EplSdoComSdoAbort(tEplSdoComConHdl SdoComConHdl_p, tEplKernel EplSdoComSdoAbort(tEplSdoComConHdl SdoComConHdl_p,
DWORD dwAbortCode_p) DWORD dwAbortCode_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplSdoComCon *pSdoComCon; tEplSdoComCon *pSdoComCon;
@ -803,9 +802,9 @@ tEplKernel PUBLIC EplSdoComSdoAbort(tEplSdoComConHdl SdoComConHdl_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoComReceiveCb(tEplSdoSeqConHdl SdoSeqConHdl_p, tEplKernel EplSdoComReceiveCb(tEplSdoSeqConHdl SdoSeqConHdl_p,
tEplAsySdoCom * pAsySdoCom_p, tEplAsySdoCom *pAsySdoCom_p,
unsigned int uiDataSize_p) unsigned int uiDataSize_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -840,8 +839,8 @@ tEplKernel PUBLIC EplSdoComReceiveCb(tEplSdoSeqConHdl SdoSeqConHdl_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoComConCb(tEplSdoSeqConHdl SdoSeqConHdl_p, tEplKernel EplSdoComConCb(tEplSdoSeqConHdl SdoSeqConHdl_p,
tEplAsySdoConState AsySdoConState_p) tEplAsySdoConState AsySdoConState_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplSdoComConEvent SdoComConEvent = kEplSdoComConEventSendFirst; tEplSdoComConEvent SdoComConEvent = kEplSdoComConEventSendFirst;

23
drivers/staging/epl/EplSdoUdpu.c
View File

@ -134,7 +134,7 @@ static tEplSdoUdpInstance SdoUdpInstance_g;
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if (TARGET_SYSTEM == _WIN32_) #if (TARGET_SYSTEM == _WIN32_)
static DWORD PUBLIC EplSdoUdpThread(LPVOID lpParameter); static DWORD EplSdoUdpThread(LPVOID lpParameter);
#elif (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__) #elif (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)
static int EplSdoUdpThread(void *pArg_p); static int EplSdoUdpThread(void *pArg_p);
@ -177,7 +177,7 @@ static int EplSdoUdpThread(void *pArg_p);
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoUdpuInit(tEplSequLayerReceiveCb fpReceiveCb_p) tEplKernel EplSdoUdpuInit(tEplSequLayerReceiveCb fpReceiveCb_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -205,7 +205,7 @@ tEplKernel PUBLIC EplSdoUdpuInit(tEplSequLayerReceiveCb fpReceiveCb_p)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoUdpuAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p) tEplKernel EplSdoUdpuAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -273,7 +273,7 @@ tEplKernel PUBLIC EplSdoUdpuAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoUdpuDelInstance() tEplKernel EplSdoUdpuDelInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -340,8 +340,7 @@ tEplKernel PUBLIC EplSdoUdpuDelInstance()
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoUdpuConfig(unsigned long ulIpAddr_p, tEplKernel EplSdoUdpuConfig(unsigned long ulIpAddr_p, unsigned int uiPort_p)
unsigned int uiPort_p)
{ {
tEplKernel Ret; tEplKernel Ret;
struct sockaddr_in Addr; struct sockaddr_in Addr;
@ -459,8 +458,8 @@ tEplKernel PUBLIC EplSdoUdpuConfig(unsigned long ulIpAddr_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoUdpuInitCon(tEplSdoConHdl * pSdoConHandle_p, tEplKernel EplSdoUdpuInitCon(tEplSdoConHdl *pSdoConHandle_p,
unsigned int uiTargetNodeId_p) unsigned int uiTargetNodeId_p)
{ {
tEplKernel Ret; tEplKernel Ret;
unsigned int uiCount; unsigned int uiCount;
@ -526,8 +525,8 @@ tEplKernel PUBLIC EplSdoUdpuInitCon(tEplSdoConHdl * pSdoConHandle_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoUdpuSendData(tEplSdoConHdl SdoConHandle_p, tEplKernel EplSdoUdpuSendData(tEplSdoConHdl SdoConHandle_p,
tEplFrame * pSrcData_p, DWORD dwDataSize_p) tEplFrame *pSrcData_p, DWORD dwDataSize_p)
{ {
tEplKernel Ret; tEplKernel Ret;
int iError; int iError;
@ -603,7 +602,7 @@ tEplKernel PUBLIC EplSdoUdpuSendData(tEplSdoConHdl SdoConHandle_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoUdpuDelCon(tEplSdoConHdl SdoConHandle_p) tEplKernel EplSdoUdpuDelCon(tEplSdoConHdl SdoConHandle_p)
{ {
tEplKernel Ret; tEplKernel Ret;
unsigned int uiArray; unsigned int uiArray;
@ -649,7 +648,7 @@ tEplKernel PUBLIC EplSdoUdpuDelCon(tEplSdoConHdl SdoConHandle_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if (TARGET_SYSTEM == _WIN32_) #if (TARGET_SYSTEM == _WIN32_)
static DWORD PUBLIC EplSdoUdpThread(LPVOID lpParameter) static DWORD EplSdoUdpThread(LPVOID lpParameter)
#elif (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__) #elif (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)
static int EplSdoUdpThread(void *pArg_p) static int EplSdoUdpThread(void *pArg_p)
#endif #endif

19
drivers/staging/epl/EplStatusu.c
View File

@ -137,8 +137,7 @@ static tEplStatusuInstance EplStatusuInstance_g;
// local function prototypes // local function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplStatusuCbStatusResponse(tEplFrameInfo * static tEplKernel EplStatusuCbStatusResponse(tEplFrameInfo *pFrameInfo_p);
pFrameInfo_p);
//=========================================================================// //=========================================================================//
// // // //
@ -164,7 +163,7 @@ static tEplKernel PUBLIC EplStatusuCbStatusResponse(tEplFrameInfo *
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplStatusuInit() EPLDLLEXPORT tEplKernel EplStatusuInit(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -191,7 +190,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplStatusuInit()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplStatusuAddInstance() EPLDLLEXPORT tEplKernel EplStatusuAddInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -228,7 +227,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplStatusuAddInstance()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplStatusuDelInstance() EPLDLLEXPORT tEplKernel EplStatusuDelInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -258,7 +257,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplStatusuDelInstance()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplStatusuReset() EPLDLLEXPORT tEplKernel EplStatusuReset(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -287,9 +286,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplStatusuReset()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplStatusuRequestStatusResponse(unsigned int uiNodeId_p, tEplKernel EplStatusuRequestStatusResponse(unsigned int uiNodeId_p,
tEplStatusuCbResponse tEplStatusuCbResponse pfnCbResponse_p)
pfnCbResponse_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -342,8 +340,7 @@ tEplKernel PUBLIC EplStatusuRequestStatusResponse(unsigned int uiNodeId_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel PUBLIC EplStatusuCbStatusResponse(tEplFrameInfo * static tEplKernel EplStatusuCbStatusResponse(tEplFrameInfo *pFrameInfo_p)
pFrameInfo_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
unsigned int uiNodeId; unsigned int uiNodeId;

18
drivers/staging/epl/EplTarget.h
View File

@ -217,17 +217,15 @@ void trace(const char *fmt, ...);
// currently no Timer functions are needed by EPL stack // currently no Timer functions are needed by EPL stack
// so they are not implemented yet // so they are not implemented yet
//void PUBLIC TgtTimerInit(void); //void TgtTimerInit(void);
//DWORD PUBLIC TgtGetTickCount(void); //DWORD TgtGetTickCount(void);
//void PUBLIC TgtGetNetTime(tEplNetTime * pNetTime_p); //void TgtGetNetTime(tEplNetTime * pNetTime_p);
// functions for ethernet driver // functions for ethernet driver
tEplKernel PUBLIC TgtInitEthIsr(void); tEplKernel TgtInitEthIsr(void);
void PUBLIC TgtFreeEthIsr(void); void TgtFreeEthIsr(void);
void PUBLIC TgtEnableGlobalInterrupt(BYTE fEnable_p); void TgtEnableGlobalInterrupt(BYTE fEnable_p);
void PUBLIC TgtEnableEthInterrupt0(BYTE fEnable_p, void TgtEnableEthInterrupt0(BYTE fEnable_p, unsigned int uiInterruptMask_p);
unsigned int uiInterruptMask_p); void TgtEnableEthInterrupt1(BYTE fEnable_p, unsigned int uiInterruptMask_p);
void PUBLIC TgtEnableEthInterrupt1(BYTE fEnable_p,
unsigned int uiInterruptMask_p);
#endif // #ifndef _EPLTARGET_H_ #endif // #ifndef _EPLTARGET_H_

3
drivers/staging/epl/EplTimer.h
View File

@ -107,8 +107,7 @@ typedef struct {
} tEplTimerEventArg; } tEplTimerEventArg;
typedef tEplKernel(PUBLIC * tEplTimerkCallback) (tEplTimerEventArg * typedef tEplKernel(* tEplTimerkCallback) (tEplTimerEventArg *pEventArg_p);
pEventArg_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// function prototypes // function prototypes

26
drivers/staging/epl/EplTimeruLinuxKernel.c
View File

@ -99,7 +99,7 @@ typedef struct {
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// local function prototypes // local function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void PUBLIC EplTimeruCbMs(unsigned long ulParameter_p); static void EplTimeruCbMs(unsigned long ulParameter_p);
/***************************************************************************/ /***************************************************************************/
/* */ /* */
@ -134,7 +134,7 @@ static void PUBLIC EplTimeruCbMs(unsigned long ulParameter_p);
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplTimeruInit() tEplKernel EplTimeruInit(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -157,7 +157,7 @@ tEplKernel PUBLIC EplTimeruInit()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplTimeruAddInstance() tEplKernel EplTimeruAddInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -182,7 +182,7 @@ tEplKernel PUBLIC EplTimeruAddInstance()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplTimeruDelInstance() tEplKernel EplTimeruDelInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -207,9 +207,9 @@ tEplKernel PUBLIC EplTimeruDelInstance()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplTimeruSetTimerMs(tEplTimerHdl * pTimerHdl_p, tEplKernel EplTimeruSetTimerMs(tEplTimerHdl *pTimerHdl_p,
unsigned long ulTime_p, unsigned long ulTime_p,
tEplTimerArg Argument_p) tEplTimerArg Argument_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
tEplTimeruData *pData; tEplTimeruData *pData;
@ -257,9 +257,9 @@ tEplKernel PUBLIC EplTimeruSetTimerMs(tEplTimerHdl * pTimerHdl_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplTimeruModifyTimerMs(tEplTimerHdl * pTimerHdl_p, tEplKernel EplTimeruModifyTimerMs(tEplTimerHdl *pTimerHdl_p,
unsigned long ulTime_p, unsigned long ulTime_p,
tEplTimerArg Argument_p) tEplTimerArg Argument_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
tEplTimeruData *pData; tEplTimeruData *pData;
@ -315,7 +315,7 @@ tEplKernel PUBLIC EplTimeruModifyTimerMs(tEplTimerHdl * pTimerHdl_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplTimeruDeleteTimer(tEplTimerHdl * pTimerHdl_p) tEplKernel EplTimeruDeleteTimer(tEplTimerHdl *pTimerHdl_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
tEplTimeruData *pData; tEplTimeruData *pData;
@ -370,7 +370,7 @@ tEplKernel PUBLIC EplTimeruDeleteTimer(tEplTimerHdl * pTimerHdl_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
BOOL PUBLIC EplTimeruIsTimerActive(tEplTimerHdl TimerHdl_p) BOOL EplTimeruIsTimerActive(tEplTimerHdl TimerHdl_p)
{ {
BOOL fActive = FALSE; BOOL fActive = FALSE;
tEplTimeruData *pData; tEplTimeruData *pData;
@ -417,7 +417,7 @@ BOOL PUBLIC EplTimeruIsTimerActive(tEplTimerHdl TimerHdl_p)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void PUBLIC EplTimeruCbMs(unsigned long ulParameter_p) static void EplTimeruCbMs(unsigned long ulParameter_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
tEplTimeruData *pData; tEplTimeruData *pData;

23
drivers/staging/epl/TimerHighReskX86.c
View File

@ -103,8 +103,8 @@
// TracePoint support for realtime-debugging // TracePoint support for realtime-debugging
#ifdef _DBG_TRACE_POINTS_ #ifdef _DBG_TRACE_POINTS_
void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p); void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p); void TgtDbgPostTraceValue(DWORD dwTraceValue_p);
#define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p) #define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p)
#define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v) #define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v)
#else #else
@ -172,7 +172,7 @@ enum hrtimer_restart EplTimerHighReskCallback(struct hrtimer *pTimer_p);
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplTimerHighReskInit(void) tEplKernel EplTimerHighReskInit(void)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -196,7 +196,7 @@ tEplKernel PUBLIC EplTimerHighReskInit(void)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplTimerHighReskAddInstance(void) tEplKernel EplTimerHighReskAddInstance(void)
{ {
tEplKernel Ret; tEplKernel Ret;
unsigned int uiIndex; unsigned int uiIndex;
@ -244,7 +244,7 @@ tEplKernel PUBLIC EplTimerHighReskAddInstance(void)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplTimerHighReskDelInstance(void) tEplKernel EplTimerHighReskDelInstance(void)
{ {
tEplTimerHighReskTimerInfo *pTimerInfo; tEplTimerHighReskTimerInfo *pTimerInfo;
tEplKernel Ret; tEplKernel Ret;
@ -298,12 +298,11 @@ tEplKernel PUBLIC EplTimerHighReskDelInstance(void)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplTimerHighReskModifyTimerNs(tEplTimerHdl * pTimerHdl_p, tEplKernel EplTimerHighReskModifyTimerNs(tEplTimerHdl *pTimerHdl_p,
unsigned long long ullTimeNs_p, unsigned long long ullTimeNs_p,
tEplTimerkCallback tEplTimerkCallback pfnCallback_p,
pfnCallback_p, unsigned long ulArgument_p,
unsigned long ulArgument_p, BOOL fContinuously_p)
BOOL fContinuously_p)
{ {
tEplKernel Ret; tEplKernel Ret;
unsigned int uiIndex; unsigned int uiIndex;
@ -396,7 +395,7 @@ tEplKernel PUBLIC EplTimerHighReskModifyTimerNs(tEplTimerHdl * pTimerHdl_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplTimerHighReskDeleteTimer(tEplTimerHdl * pTimerHdl_p) tEplKernel EplTimerHighReskDeleteTimer(tEplTimerHdl *pTimerHdl_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
unsigned int uiIndex; unsigned int uiIndex;

4
drivers/staging/epl/VirtualEthernetLinux.c
View File

@ -285,7 +285,7 @@ static tEplKernel VEthRecvFrame(tEplFrameInfo * pFrameInfo_p)
return Ret; return Ret;
} }
tEplKernel PUBLIC VEthAddInstance(tEplDllkInitParam * pInitParam_p) tEplKernel VEthAddInstance(tEplDllkInitParam *pInitParam_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
@ -324,7 +324,7 @@ tEplKernel PUBLIC VEthAddInstance(tEplDllkInitParam * pInitParam_p)
return Ret; return Ret;
} }
tEplKernel PUBLIC VEthDelInstance(void) tEplKernel VEthDelInstance(void)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;

106
drivers/staging/epl/amix86.c
View File

@ -119,7 +119,7 @@ typedef struct {
//------------< write BYTE in big endian >-------------------------- //------------< write BYTE in big endian >--------------------------
/* /*
void PUBLIC AmiSetByteToBe (void FAR* pAddr_p, BYTE bByteVal_p) void AmiSetByteToBe (void FAR* pAddr_p, BYTE bByteVal_p)
{ {
*(BYTE FAR*)pAddr_p = bByteVal_p; *(BYTE FAR*)pAddr_p = bByteVal_p;
@ -129,7 +129,7 @@ void PUBLIC AmiSetByteToBe (void FAR* pAddr_p, BYTE bByteVal_p)
//------------< write WORD in big endian >-------------------------- //------------< write WORD in big endian >--------------------------
INLINE_FUNCTION void PUBLIC AmiSetWordToBe(void FAR * pAddr_p, WORD wWordVal_p) INLINE_FUNCTION void AmiSetWordToBe(void FAR * pAddr_p, WORD wWordVal_p)
{ {
twStruct FAR *pwStruct; twStruct FAR *pwStruct;
twStruct wValue; twStruct wValue;
@ -144,8 +144,7 @@ INLINE_FUNCTION void PUBLIC AmiSetWordToBe(void FAR * pAddr_p, WORD wWordVal_p)
//------------< write DWORD in big endian >------------------------- //------------< write DWORD in big endian >-------------------------
INLINE_FUNCTION void PUBLIC AmiSetDwordToBe(void FAR * pAddr_p, INLINE_FUNCTION void AmiSetDwordToBe(void FAR *pAddr_p, DWORD dwDwordVal_p)
DWORD dwDwordVal_p)
{ {
tdwStruct FAR *pdwStruct; tdwStruct FAR *pdwStruct;
tdwStruct dwValue; tdwStruct dwValue;
@ -178,7 +177,7 @@ INLINE_FUNCTION void PUBLIC AmiSetDwordToBe(void FAR * pAddr_p,
//------------< write BYTE in little endian >-------------------------- //------------< write BYTE in little endian >--------------------------
/* /*
void PUBLIC AmiSetByteToLe (void FAR* pAddr_p, BYTE bByteVal_p) void AmiSetByteToLe (void FAR* pAddr_p, BYTE bByteVal_p)
{ {
*(BYTE FAR*)pAddr_p = bByteVal_p; *(BYTE FAR*)pAddr_p = bByteVal_p;
@ -188,7 +187,7 @@ void PUBLIC AmiSetByteToLe (void FAR* pAddr_p, BYTE bByteVal_p)
//------------< write WORD in little endian >-------------------------- //------------< write WORD in little endian >--------------------------
INLINE_FUNCTION void PUBLIC AmiSetWordToLe(void FAR * pAddr_p, WORD wWordVal_p) INLINE_FUNCTION void AmiSetWordToLe(void FAR *pAddr_p, WORD wWordVal_p)
{ {
twStruct FAR *pwStruct; twStruct FAR *pwStruct;
@ -199,8 +198,7 @@ INLINE_FUNCTION void PUBLIC AmiSetWordToLe(void FAR * pAddr_p, WORD wWordVal_p)
//------------< write DWORD in little endian >------------------------- //------------< write DWORD in little endian >-------------------------
INLINE_FUNCTION void PUBLIC AmiSetDwordToLe(void FAR * pAddr_p, INLINE_FUNCTION void AmiSetDwordToLe(void FAR *pAddr_p, DWORD dwDwordVal_p)
DWORD dwDwordVal_p)
{ {
tdwStruct FAR *pdwStruct; tdwStruct FAR *pdwStruct;
@ -226,7 +224,7 @@ INLINE_FUNCTION void PUBLIC AmiSetDwordToLe(void FAR * pAddr_p,
//------------< read BYTE in big endian >--------------------------- //------------< read BYTE in big endian >---------------------------
/* /*
BYTE PUBLIC AmiGetByteFromBe (void FAR* pAddr_p) BYTE AmiGetByteFromBe (void FAR* pAddr_p)
{ {
return ( *(BYTE FAR*)pAddr_p ); return ( *(BYTE FAR*)pAddr_p );
@ -236,7 +234,7 @@ BYTE PUBLIC AmiGetByteFromBe (void FAR* pAddr_p)
//------------< read WORD in big endian >--------------------------- //------------< read WORD in big endian >---------------------------
INLINE_FUNCTION WORD PUBLIC AmiGetWordFromBe(void FAR * pAddr_p) INLINE_FUNCTION WORD AmiGetWordFromBe(void FAR *pAddr_p)
{ {
twStruct FAR *pwStruct; twStruct FAR *pwStruct;
twStruct wValue; twStruct wValue;
@ -252,7 +250,7 @@ INLINE_FUNCTION WORD PUBLIC AmiGetWordFromBe(void FAR * pAddr_p)
//------------< read DWORD in big endian >-------------------------- //------------< read DWORD in big endian >--------------------------
INLINE_FUNCTION DWORD PUBLIC AmiGetDwordFromBe(void FAR * pAddr_p) INLINE_FUNCTION DWORD AmiGetDwordFromBe(void FAR *pAddr_p)
{ {
tdwStruct FAR *pdwStruct; tdwStruct FAR *pdwStruct;
tdwStruct dwValue; tdwStruct dwValue;
@ -285,7 +283,7 @@ INLINE_FUNCTION DWORD PUBLIC AmiGetDwordFromBe(void FAR * pAddr_p)
//------------< read BYTE in little endian >--------------------------- //------------< read BYTE in little endian >---------------------------
/* /*
BYTE PUBLIC AmiGetByteFromLe (void FAR* pAddr_p) BYTE AmiGetByteFromLe (void FAR* pAddr_p)
{ {
return ( *(BYTE FAR*)pAddr_p ); return ( *(BYTE FAR*)pAddr_p );
@ -295,24 +293,22 @@ BYTE PUBLIC AmiGetByteFromLe (void FAR* pAddr_p)
//------------< read WORD in little endian >--------------------------- //------------< read WORD in little endian >---------------------------
INLINE_FUNCTION WORD PUBLIC AmiGetWordFromLe(void FAR * pAddr_p) INLINE_FUNCTION WORD AmiGetWordFromLe(void FAR *pAddr_p)
{ {
twStruct FAR *pwStruct; twStruct FAR *pwStruct;
pwStruct = (twStruct FAR *) pAddr_p; pwStruct = (twStruct FAR *) pAddr_p;
return (pwStruct->m_wWord); return (pwStruct->m_wWord);
} }
//------------< read DWORD in little endian >-------------------------- //------------< read DWORD in little endian >--------------------------
INLINE_FUNCTION DWORD PUBLIC AmiGetDwordFromLe(void FAR * pAddr_p) INLINE_FUNCTION DWORD AmiGetDwordFromLe(void FAR *pAddr_p)
{ {
tdwStruct FAR *pdwStruct; tdwStruct FAR *pdwStruct;
pdwStruct = (tdwStruct FAR *) pAddr_p; pdwStruct = (tdwStruct FAR *) pAddr_p;
return (pdwStruct->m_dwDword); return (pdwStruct->m_dwDword);
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -330,14 +326,11 @@ INLINE_FUNCTION DWORD PUBLIC AmiGetDwordFromLe(void FAR * pAddr_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION void PUBLIC AmiSetDword24ToBe(void FAR * pAddr_p, INLINE_FUNCTION void AmiSetDword24ToBe(void FAR *pAddr_p, DWORD dwDwordVal_p)
DWORD dwDwordVal_p)
{ {
((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & dwDwordVal_p)[2]; ((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & dwDwordVal_p)[2];
((BYTE FAR *) pAddr_p)[1] = ((BYTE FAR *) & dwDwordVal_p)[1]; ((BYTE FAR *) pAddr_p)[1] = ((BYTE FAR *) & dwDwordVal_p)[1];
((BYTE FAR *) pAddr_p)[2] = ((BYTE FAR *) & dwDwordVal_p)[0]; ((BYTE FAR *) pAddr_p)[2] = ((BYTE FAR *) & dwDwordVal_p)[0];
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -355,14 +348,11 @@ INLINE_FUNCTION void PUBLIC AmiSetDword24ToBe(void FAR * pAddr_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION void PUBLIC AmiSetDword24ToLe(void FAR * pAddr_p, INLINE_FUNCTION void AmiSetDword24ToLe(void FAR *pAddr_p, DWORD dwDwordVal_p)
DWORD dwDwordVal_p)
{ {
((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & dwDwordVal_p)[0]; ((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & dwDwordVal_p)[0];
((BYTE FAR *) pAddr_p)[1] = ((BYTE FAR *) & dwDwordVal_p)[1]; ((BYTE FAR *) pAddr_p)[1] = ((BYTE FAR *) & dwDwordVal_p)[1];
((BYTE FAR *) pAddr_p)[2] = ((BYTE FAR *) & dwDwordVal_p)[2]; ((BYTE FAR *) pAddr_p)[2] = ((BYTE FAR *) & dwDwordVal_p)[2];
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -378,17 +368,14 @@ INLINE_FUNCTION void PUBLIC AmiSetDword24ToLe(void FAR * pAddr_p,
// State: not tested // State: not tested
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION DWORD AmiGetDword24FromBe(void FAR *pAddr_p)
INLINE_FUNCTION DWORD PUBLIC AmiGetDword24FromBe(void FAR * pAddr_p)
{ {
tdwStruct dwStruct; tdwStruct dwStruct;
dwStruct.m_dwDword = AmiGetDwordFromBe(pAddr_p); dwStruct.m_dwDword = AmiGetDwordFromBe(pAddr_p);
dwStruct.m_dwDword >>= 8; dwStruct.m_dwDword >>= 8;
return (dwStruct.m_dwDword); return (dwStruct.m_dwDword);
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -404,17 +391,14 @@ INLINE_FUNCTION DWORD PUBLIC AmiGetDword24FromBe(void FAR * pAddr_p)
// State: not tested // State: not tested
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION DWORD AmiGetDword24FromLe(void FAR *pAddr_p)
INLINE_FUNCTION DWORD PUBLIC AmiGetDword24FromLe(void FAR * pAddr_p)
{ {
tdwStruct dwStruct; tdwStruct dwStruct;
dwStruct.m_dwDword = AmiGetDwordFromLe(pAddr_p); dwStruct.m_dwDword = AmiGetDwordFromLe(pAddr_p);
dwStruct.m_dwDword &= 0x00FFFFFF; dwStruct.m_dwDword &= 0x00FFFFFF;
return (dwStruct.m_dwDword); return (dwStruct.m_dwDword);
} }
//#ifdef USE_VAR64 //#ifdef USE_VAR64
@ -433,11 +417,8 @@ INLINE_FUNCTION DWORD PUBLIC AmiGetDword24FromLe(void FAR * pAddr_p)
// State: not tested // State: not tested
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION void AmiSetQword64ToBe(void FAR *pAddr_p, QWORD qwQwordVal_p)
INLINE_FUNCTION void PUBLIC AmiSetQword64ToBe(void FAR * pAddr_p,
QWORD qwQwordVal_p)
{ {
((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & qwQwordVal_p)[7]; ((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & qwQwordVal_p)[7];
((BYTE FAR *) pAddr_p)[1] = ((BYTE FAR *) & qwQwordVal_p)[6]; ((BYTE FAR *) pAddr_p)[1] = ((BYTE FAR *) & qwQwordVal_p)[6];
((BYTE FAR *) pAddr_p)[2] = ((BYTE FAR *) & qwQwordVal_p)[5]; ((BYTE FAR *) pAddr_p)[2] = ((BYTE FAR *) & qwQwordVal_p)[5];
@ -446,7 +427,6 @@ INLINE_FUNCTION void PUBLIC AmiSetQword64ToBe(void FAR * pAddr_p,
((BYTE FAR *) pAddr_p)[5] = ((BYTE FAR *) & qwQwordVal_p)[2]; ((BYTE FAR *) pAddr_p)[5] = ((BYTE FAR *) & qwQwordVal_p)[2];
((BYTE FAR *) pAddr_p)[6] = ((BYTE FAR *) & qwQwordVal_p)[1]; ((BYTE FAR *) pAddr_p)[6] = ((BYTE FAR *) & qwQwordVal_p)[1];
((BYTE FAR *) pAddr_p)[7] = ((BYTE FAR *) & qwQwordVal_p)[0]; ((BYTE FAR *) pAddr_p)[7] = ((BYTE FAR *) & qwQwordVal_p)[0];
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -463,16 +443,12 @@ INLINE_FUNCTION void PUBLIC AmiSetQword64ToBe(void FAR * pAddr_p,
// State: not tested // State: not tested
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION void AmiSetQword64ToLe(void FAR *pAddr_p, QWORD qwQwordVal_p)
INLINE_FUNCTION void PUBLIC AmiSetQword64ToLe(void FAR * pAddr_p,
QWORD qwQwordVal_p)
{ {
QWORD FAR *pqwDst; QWORD FAR *pqwDst;
pqwDst = (QWORD FAR *) pAddr_p; pqwDst = (QWORD FAR *) pAddr_p;
*pqwDst = qwQwordVal_p; *pqwDst = qwQwordVal_p;
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -488,10 +464,8 @@ INLINE_FUNCTION void PUBLIC AmiSetQword64ToLe(void FAR * pAddr_p,
// State: not tested // State: not tested
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION QWORD AmiGetQword64FromBe(void FAR *pAddr_p)
INLINE_FUNCTION QWORD PUBLIC AmiGetQword64FromBe(void FAR * pAddr_p)
{ {
tqwStruct qwStruct; tqwStruct qwStruct;
((BYTE FAR *) & qwStruct.m_qwQword)[0] = ((BYTE FAR *) pAddr_p)[7]; ((BYTE FAR *) & qwStruct.m_qwQword)[0] = ((BYTE FAR *) pAddr_p)[7];
@ -504,7 +478,6 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword64FromBe(void FAR * pAddr_p)
((BYTE FAR *) & qwStruct.m_qwQword)[7] = ((BYTE FAR *) pAddr_p)[0]; ((BYTE FAR *) & qwStruct.m_qwQword)[7] = ((BYTE FAR *) pAddr_p)[0];
return (qwStruct.m_qwQword); return (qwStruct.m_qwQword);
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -520,10 +493,8 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword64FromBe(void FAR * pAddr_p)
// State: not tested // State: not tested
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION QWORD AmiGetQword64FromLe(void FAR *pAddr_p)
INLINE_FUNCTION QWORD PUBLIC AmiGetQword64FromLe(void FAR * pAddr_p)
{ {
tqwStruct FAR *pqwStruct; tqwStruct FAR *pqwStruct;
tqwStruct qwStruct; tqwStruct qwStruct;
@ -531,7 +502,6 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword64FromLe(void FAR * pAddr_p)
qwStruct.m_qwQword = pqwStruct->m_qwQword; qwStruct.m_qwQword = pqwStruct->m_qwQword;
return (qwStruct.m_qwQword); return (qwStruct.m_qwQword);
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -549,8 +519,7 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword64FromLe(void FAR * pAddr_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION void PUBLIC AmiSetQword40ToBe(void FAR * pAddr_p, INLINE_FUNCTION void AmiSetQword40ToBe(void FAR *pAddr_p, QWORD qwQwordVal_p)
QWORD qwQwordVal_p)
{ {
((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & qwQwordVal_p)[4]; ((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & qwQwordVal_p)[4];
@ -576,8 +545,7 @@ INLINE_FUNCTION void PUBLIC AmiSetQword40ToBe(void FAR * pAddr_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION void PUBLIC AmiSetQword40ToLe(void FAR * pAddr_p, INLINE_FUNCTION void AmiSetQword40ToLe(void FAR *pAddr_p, QWORD qwQwordVal_p)
QWORD qwQwordVal_p)
{ {
((DWORD FAR *) pAddr_p)[0] = ((DWORD FAR *) & qwQwordVal_p)[0]; ((DWORD FAR *) pAddr_p)[0] = ((DWORD FAR *) & qwQwordVal_p)[0];
@ -599,7 +567,7 @@ INLINE_FUNCTION void PUBLIC AmiSetQword40ToLe(void FAR * pAddr_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION QWORD PUBLIC AmiGetQword40FromBe(void FAR * pAddr_p) INLINE_FUNCTION QWORD AmiGetQword40FromBe(void FAR *pAddr_p)
{ {
tqwStruct qwStruct; tqwStruct qwStruct;
@ -625,7 +593,7 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword40FromBe(void FAR * pAddr_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION QWORD PUBLIC AmiGetQword40FromLe(void FAR * pAddr_p) INLINE_FUNCTION QWORD AmiGetQword40FromLe(void FAR *pAddr_p)
{ {
tqwStruct qwStruct; tqwStruct qwStruct;
@ -652,8 +620,7 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword40FromLe(void FAR * pAddr_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION void PUBLIC AmiSetQword48ToBe(void FAR * pAddr_p, INLINE_FUNCTION void AmiSetQword48ToBe(void FAR *pAddr_p, QWORD qwQwordVal_p)
QWORD qwQwordVal_p)
{ {
((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & qwQwordVal_p)[5]; ((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & qwQwordVal_p)[5];
@ -680,8 +647,7 @@ INLINE_FUNCTION void PUBLIC AmiSetQword48ToBe(void FAR * pAddr_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION void PUBLIC AmiSetQword48ToLe(void FAR * pAddr_p, INLINE_FUNCTION void AmiSetQword48ToLe(void FAR *pAddr_p, QWORD qwQwordVal_p)
QWORD qwQwordVal_p)
{ {
((DWORD FAR *) pAddr_p)[0] = ((DWORD FAR *) & qwQwordVal_p)[0]; ((DWORD FAR *) pAddr_p)[0] = ((DWORD FAR *) & qwQwordVal_p)[0];
@ -703,7 +669,7 @@ INLINE_FUNCTION void PUBLIC AmiSetQword48ToLe(void FAR * pAddr_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION QWORD PUBLIC AmiGetQword48FromBe(void FAR * pAddr_p) INLINE_FUNCTION QWORD AmiGetQword48FromBe(void FAR *pAddr_p)
{ {
tqwStruct qwStruct; tqwStruct qwStruct;
@ -729,7 +695,7 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword48FromBe(void FAR * pAddr_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION QWORD PUBLIC AmiGetQword48FromLe(void FAR * pAddr_p) INLINE_FUNCTION QWORD AmiGetQword48FromLe(void FAR *pAddr_p)
{ {
tqwStruct qwStruct; tqwStruct qwStruct;
@ -756,8 +722,7 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword48FromLe(void FAR * pAddr_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION void PUBLIC AmiSetQword56ToBe(void FAR * pAddr_p, INLINE_FUNCTION void AmiSetQword56ToBe(void FAR *pAddr_p, QWORD qwQwordVal_p)
QWORD qwQwordVal_p)
{ {
((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & qwQwordVal_p)[6]; ((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & qwQwordVal_p)[6];
@ -785,8 +750,7 @@ INLINE_FUNCTION void PUBLIC AmiSetQword56ToBe(void FAR * pAddr_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION void PUBLIC AmiSetQword56ToLe(void FAR * pAddr_p, INLINE_FUNCTION void AmiSetQword56ToLe(void FAR *pAddr_p, QWORD qwQwordVal_p)
QWORD qwQwordVal_p)
{ {
((DWORD FAR *) pAddr_p)[0] = ((DWORD FAR *) & qwQwordVal_p)[0]; ((DWORD FAR *) pAddr_p)[0] = ((DWORD FAR *) & qwQwordVal_p)[0];
@ -809,7 +773,7 @@ INLINE_FUNCTION void PUBLIC AmiSetQword56ToLe(void FAR * pAddr_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION QWORD PUBLIC AmiGetQword56FromBe(void FAR * pAddr_p) INLINE_FUNCTION QWORD AmiGetQword56FromBe(void FAR *pAddr_p)
{ {
tqwStruct qwStruct; tqwStruct qwStruct;
@ -835,7 +799,7 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword56FromBe(void FAR * pAddr_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION QWORD PUBLIC AmiGetQword56FromLe(void FAR * pAddr_p) INLINE_FUNCTION QWORD AmiGetQword56FromLe(void FAR *pAddr_p)
{ {
tqwStruct qwStruct; tqwStruct qwStruct;
@ -862,8 +826,7 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword56FromLe(void FAR * pAddr_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION void PUBLIC AmiSetTimeOfDay(void FAR * pAddr_p, INLINE_FUNCTION void AmiSetTimeOfDay(void FAR *pAddr_p, tTimeOfDay FAR *pTimeOfDay_p)
tTimeOfDay FAR * pTimeOfDay_p)
{ {
AmiSetDwordToLe(((BYTE FAR *) pAddr_p), AmiSetDwordToLe(((BYTE FAR *) pAddr_p),
@ -887,8 +850,7 @@ INLINE_FUNCTION void PUBLIC AmiSetTimeOfDay(void FAR * pAddr_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
INLINE_FUNCTION void PUBLIC AmiGetTimeOfDay(void FAR * pAddr_p, INLINE_FUNCTION void AmiGetTimeOfDay(void FAR *pAddr_p, tTimeOfDay FAR *pTimeOfDay_p)
tTimeOfDay FAR * pTimeOfDay_p)
{ {
pTimeOfDay_p->m_dwMs = pTimeOfDay_p->m_dwMs =

20
drivers/staging/epl/demo_main.c
View File

@ -118,7 +118,7 @@ MODULE_DESCRIPTION("EPL MN demo");
// TracePoint support for realtime-debugging // TracePoint support for realtime-debugging
#ifdef _DBG_TRACE_POINTS_ #ifdef _DBG_TRACE_POINTS_
void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p); void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
#define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p) #define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p)
#else #else
#define TGT_DBG_SIGNAL_TRACE_POINT(p) #define TGT_DBG_SIGNAL_TRACE_POINT(p)
@ -188,13 +188,13 @@ module_param_named(cyclelen, uiCycleLen_g, uint, 0);
// this function prototype here. If you want to use more than one Epl // this function prototype here. If you want to use more than one Epl
// instances then the function name of each object dictionary has to differ. // instances then the function name of each object dictionary has to differ.
tEplKernel PUBLIC EplObdInitRam(tEplObdInitParam MEM * pInitParam_p); tEplKernel EplObdInitRam(tEplObdInitParam MEM * pInitParam_p);
tEplKernel PUBLIC AppCbEvent(tEplApiEventType EventType_p, // IN: event type (enum) tEplKernel AppCbEvent(tEplApiEventType EventType_p, // IN: event type (enum)
tEplApiEventArg * pEventArg_p, // IN: event argument (union) tEplApiEventArg *pEventArg_p, // IN: event argument (union)
void GENERIC * pUserArg_p); void GENERIC *pUserArg_p);
tEplKernel PUBLIC AppCbSync(void); tEplKernel AppCbSync(void);
static int __init EplLinInit(void); static int __init EplLinInit(void);
static void __exit EplLinExit(void); static void __exit EplLinExit(void);
@ -484,9 +484,9 @@ static void __exit EplLinExit(void)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC AppCbEvent(tEplApiEventType EventType_p, // IN: event type (enum) tEplKernel AppCbEvent(tEplApiEventType EventType_p, // IN: event type (enum)
tEplApiEventArg * pEventArg_p, // IN: event argument (union) tEplApiEventArg *pEventArg_p, // IN: event argument (union)
void GENERIC * pUserArg_p) void GENERIC *pUserArg_p)
{ {
tEplKernel EplRet = kEplSuccessful; tEplKernel EplRet = kEplSuccessful;
@ -802,7 +802,7 @@ tEplKernel PUBLIC AppCbEvent(tEplApiEventType EventType_p, // IN: event type (en
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC AppCbSync(void) tEplKernel AppCbSync(void)
{ {
tEplKernel EplRet = kEplSuccessful; tEplKernel EplRet = kEplSuccessful;

1
drivers/staging/epl/global.h
View File

@ -180,7 +180,6 @@
#endif #endif
#define REENTRANT #define REENTRANT
#define PUBLIC
#define TRACE printk #define TRACE printk

8
drivers/staging/epl/kernel/EplErrorHandlerk.h
View File

@ -86,15 +86,15 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// init function // init function
tEplKernel PUBLIC EplErrorHandlerkInit(void); tEplKernel EplErrorHandlerkInit(void);
// add instance // add instance
tEplKernel PUBLIC EplErrorHandlerkAddInstance(void); tEplKernel EplErrorHandlerkAddInstance(void);
// delete instance // delete instance
tEplKernel PUBLIC EplErrorHandlerkDelInstance(void); tEplKernel EplErrorHandlerkDelInstance(void);
// processes error events // processes error events
tEplKernel PUBLIC EplErrorHandlerkProcess(tEplEvent * pEvent_p); tEplKernel EplErrorHandlerkProcess(tEplEvent *pEvent_p);
#endif // #ifndef _EPL_ERRORHANDLERK_H_ #endif // #ifndef _EPL_ERRORHANDLERK_H_

16
drivers/staging/epl/kernel/EplEventk.h
View File

@ -86,23 +86,23 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// init function // init function
tEplKernel PUBLIC EplEventkInit(tEplSyncCb fpSyncCb); tEplKernel EplEventkInit(tEplSyncCb fpSyncCb);
// add instance // add instance
tEplKernel PUBLIC EplEventkAddInstance(tEplSyncCb fpSyncCb); tEplKernel EplEventkAddInstance(tEplSyncCb fpSyncCb);
// delete instance // delete instance
tEplKernel PUBLIC EplEventkDelInstance(void); tEplKernel EplEventkDelInstance(void);
// Kernelthread that dispatches events in kernelspace // Kernelthread that dispatches events in kernelspace
tEplKernel PUBLIC EplEventkProcess(tEplEvent * pEvent_p); tEplKernel EplEventkProcess(tEplEvent *pEvent_p);
// post events from kernelspace // post events from kernelspace
tEplKernel PUBLIC EplEventkPost(tEplEvent * pEvent_p); tEplKernel EplEventkPost(tEplEvent *pEvent_p);
// post errorevents from kernelspace // post errorevents from kernelspace
tEplKernel PUBLIC EplEventkPostError(tEplEventSource EventSource_p, tEplKernel EplEventkPostError(tEplEventSource EventSource_p,
tEplKernel EplError_p, tEplKernel EplError_p,
unsigned int uiArgSize_p, void *pArg_p); unsigned int uiArgSize_p, void *pArg_p);
#endif // #ifndef _EPL_EVENTK_H_ #endif // #ifndef _EPL_EVENTK_H_

14
drivers/staging/epl/kernel/EplNmtk.h
View File

@ -86,19 +86,15 @@
// function prototypes // function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) != 0) #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) != 0)
EPLDLLEXPORT tEplKernel PUBLIC EplNmtkInit(EPL_MCO_DECL_PTR_INSTANCE_PTR); EPLDLLEXPORT tEplKernel EplNmtkInit(EPL_MCO_DECL_PTR_INSTANCE_PTR);
EPLDLLEXPORT tEplKernel PUBLIC EPLDLLEXPORT tEplKernel EplNmtkAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR);
EplNmtkAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR);
EPLDLLEXPORT tEplKernel PUBLIC EPLDLLEXPORT tEplKernel EplNmtkDelInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR);
EplNmtkDelInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR);
EPLDLLEXPORT tEplKernel PUBLIC EplNmtkProcess(EPL_MCO_DECL_PTR_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplNmtkProcess(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplEvent *pEvent_p);
tEplEvent * pEvent_p);
EPLDLLEXPORT tEplNmtState PUBLIC EPLDLLEXPORT tEplNmtState EplNmtkGetNmtState(EPL_MCO_DECL_PTR_INSTANCE_PTR);
EplNmtkGetNmtState(EPL_MCO_DECL_PTR_INSTANCE_PTR);
#endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) != 0) #endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) != 0)

145
drivers/staging/epl/kernel/EplObdk.h
View File

@ -92,104 +92,83 @@ extern BYTE MEM abEplObdTrashObject_g[8];
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0) #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdInit(EPL_MCO_DECL_PTR_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObdInit(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitParam MEM *pInitParam_p);
tEplObdInitParam MEM * pInitParam_p);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObdAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitParam MEM *pInitParam_p);
tEplObdInitParam MEM *
pInitParam_p);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdDeleteInstance(EPL_MCO_DECL_INSTANCE_PTR); EPLDLLEXPORT tEplKernel EplObdDeleteInstance(EPL_MCO_DECL_INSTANCE_PTR);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdWriteEntry(EPL_MCO_DECL_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObdWriteEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiIndex_p, unsigned int uiSubIndex_p,
unsigned int uiSubIndex_p, void *pSrcData_p,
void *pSrcData_p, tEplObdSize Size_p);
tEplObdSize Size_p);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdReadEntry(EPL_MCO_DECL_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObdReadEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiIndex_p, unsigned int uiSubIndex_p,
void *pDstData_p,
tEplObdSize *pSize_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObdSetStoreLoadObjCallback(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdStoreLoadObjCallback fpCallback_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObdAccessOdPart(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdPart ObdPart_p,
tEplObdDir Direction_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObdDefineVar(EPL_MCO_DECL_INSTANCE_PTR_ tEplVarParam MEM *pVarParam_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT void *EplObdGetObjectDataPtr(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiSubIndex_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObdRegisterUserOd(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPtr pUserOd_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT void EplObdInitVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdVarEntry MEM *pVarEntry_p,
tEplObdType Type_p,
tEplObdSize ObdSize_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplObdSize EplObdGetDataSize(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiSubIndex_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT unsigned int EplObdGetNodeId(EPL_MCO_DECL_INSTANCE_PTR);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObdSetNodeId(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiNodeId_p,
tEplObdNodeIdType NodeIdType_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObdIsNumerical(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiSubIndex_p,
BOOL *pfEntryNumerical);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObdWriteEntryFromLe(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiSubIndex_p, unsigned int uiSubIndex_p,
void *pDstData_p, void *pSrcData_p,
tEplObdSize * pSize_p); tEplObdSize Size_p);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EPLDLLEXPORT tEplKernel EplObdReadEntryToLe(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
EplObdSetStoreLoadObjCallback(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiSubIndex_p,
tEplObdStoreLoadObjCallback fpCallback_p); void *pDstData_p,
tEplObdSize *pSize_p);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdAccessOdPart(EPL_MCO_DECL_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObdGetAccessType(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
tEplObdPart ObdPart_p, unsigned int uiSubIndex_p,
tEplObdDir Direction_p); tEplObdAccess *pAccessTyp_p);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdDefineVar(EPL_MCO_DECL_INSTANCE_PTR_ EPLDLLEXPORT tEplKernel EplObdSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
tEplVarParam MEM * pVarParam_p); unsigned int uiSubindex_p,
tEplObdVarEntry MEM **ppVarEntry_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT void *PUBLIC EplObdGetObjectDataPtr(EPL_MCO_DECL_INSTANCE_PTR_
unsigned int uiIndex_p,
unsigned int uiSubIndex_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdRegisterUserOd(EPL_MCO_DECL_INSTANCE_PTR_
tEplObdEntryPtr pUserOd_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT void PUBLIC EplObdInitVarEntry(EPL_MCO_DECL_INSTANCE_PTR_
tEplObdVarEntry MEM * pVarEntry_p,
tEplObdType Type_p,
tEplObdSize ObdSize_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplObdSize PUBLIC EplObdGetDataSize(EPL_MCO_DECL_INSTANCE_PTR_
unsigned int uiIndex_p,
unsigned int uiSubIndex_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT unsigned int PUBLIC EplObdGetNodeId(EPL_MCO_DECL_INSTANCE_PTR);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdSetNodeId(EPL_MCO_DECL_INSTANCE_PTR_
unsigned int uiNodeId_p,
tEplObdNodeIdType NodeIdType_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdIsNumerical(EPL_MCO_DECL_INSTANCE_PTR_
unsigned int uiIndex_p,
unsigned int uiSubIndex_p,
BOOL * pfEntryNumerical);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdWriteEntryFromLe(EPL_MCO_DECL_INSTANCE_PTR_
unsigned int uiIndex_p,
unsigned int uiSubIndex_p,
void *pSrcData_p,
tEplObdSize Size_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdReadEntryToLe(EPL_MCO_DECL_INSTANCE_PTR_
unsigned int uiIndex_p,
unsigned int uiSubIndex_p,
void *pDstData_p,
tEplObdSize * pSize_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdGetAccessType(EPL_MCO_DECL_INSTANCE_PTR_
unsigned int uiIndex_p,
unsigned int uiSubIndex_p,
tEplObdAccess *
pAccessTyp_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_
unsigned int uiIndex_p,
unsigned int uiSubindex_p,
tEplObdVarEntry MEM **
ppVarEntry_p);
#endif // end of #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0) #endif // end of #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)

29
drivers/staging/epl/kernel/EplTimerHighResk.h
View File

@ -85,25 +85,24 @@
// function prototypes // function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplTimerHighReskInit(void); tEplKernel EplTimerHighReskInit(void);
tEplKernel PUBLIC EplTimerHighReskAddInstance(void); tEplKernel EplTimerHighReskAddInstance(void);
tEplKernel PUBLIC EplTimerHighReskDelInstance(void); tEplKernel EplTimerHighReskDelInstance(void);
tEplKernel PUBLIC EplTimerHighReskSetTimerNs(tEplTimerHdl * pTimerHdl_p, tEplKernel EplTimerHighReskSetTimerNs(tEplTimerHdl *pTimerHdl_p,
unsigned long long ullTimeNs_p, unsigned long long ullTimeNs_p,
tEplTimerkCallback pfnCallback_p, tEplTimerkCallback pfnCallback_p,
unsigned long ulArgument_p, unsigned long ulArgument_p,
BOOL fContinuously_p); BOOL fContinuously_p);
tEplKernel PUBLIC EplTimerHighReskModifyTimerNs(tEplTimerHdl * pTimerHdl_p, tEplKernel EplTimerHighReskModifyTimerNs(tEplTimerHdl *pTimerHdl_p,
unsigned long long ullTimeNs_p, unsigned long long ullTimeNs_p,
tEplTimerkCallback tEplTimerkCallback pfnCallback_p,
pfnCallback_p, unsigned long ulArgument_p,
unsigned long ulArgument_p, BOOL fContinuously_p);
BOOL fContinuously_p);
tEplKernel PUBLIC EplTimerHighReskDeleteTimer(tEplTimerHdl * pTimerHdl_p); tEplKernel EplTimerHighReskDeleteTimer(tEplTimerHdl *pTimerHdl_p);
#endif // #ifndef _EPLTIMERHIGHRESK_H_ #endif // #ifndef _EPLTIMERHIGHRESK_H_

20
drivers/staging/epl/kernel/EplTimerk.h
View File

@ -99,20 +99,20 @@
// function prototypes // function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if EPL_TIMER_USE_USER == FALSE #if EPL_TIMER_USE_USER == FALSE
tEplKernel PUBLIC EplTimerkInit(void); tEplKernel EplTimerkInit(void);
tEplKernel PUBLIC EplTimerkAddInstance(void); tEplKernel EplTimerkAddInstance(void);
tEplKernel PUBLIC EplTimerkDelInstance(void); tEplKernel EplTimerkDelInstance(void);
tEplKernel PUBLIC EplTimerkSetTimerMs(tEplTimerHdl * pTimerHdl_p, tEplKernel EplTimerkSetTimerMs(tEplTimerHdl *pTimerHdl_p,
unsigned long ulTime_p, unsigned long ulTime_p,
tEplTimerArg Argument_p); tEplTimerArg Argument_p);
tEplKernel PUBLIC EplTimerkModifyTimerMs(tEplTimerHdl * pTimerHdl_p, tEplKernel EplTimerkModifyTimerMs(tEplTimerHdl *pTimerHdl_p,
unsigned long ulTime_p, unsigned long ulTime_p,
tEplTimerArg Argument_p); tEplTimerArg Argument_p);
tEplKernel PUBLIC EplTimerkDeleteTimer(tEplTimerHdl * pTimerHdl_p); tEplKernel EplTimerkDeleteTimer(tEplTimerHdl *pTimerHdl_p);
#endif #endif
#endif // #ifndef _EPLTIMERK_H_ #endif // #ifndef _EPLTIMERK_H_

4
drivers/staging/epl/kernel/VirtualEthernet.h
View File

@ -87,9 +87,9 @@
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_VETH)) != 0) #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_VETH)) != 0)
tEplKernel PUBLIC VEthAddInstance(tEplDllkInitParam * pInitParam_p); tEplKernel VEthAddInstance(tEplDllkInitParam *pInitParam_p);
tEplKernel PUBLIC VEthDelInstance(void); tEplKernel VEthDelInstance(void);
#endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_VETH)) != 0) #endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_VETH)) != 0)

10
drivers/staging/epl/proc_fs.c
View File

@ -145,10 +145,10 @@ static int EplLinProcRead(char *pcBuffer_p, char **ppcStart_p, off_t Offset_p,
static int EplLinProcWrite(struct file *file, const char __user * buffer, static int EplLinProcWrite(struct file *file, const char __user * buffer,
unsigned long count, void *data); unsigned long count, void *data);
void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p); void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p); void TgtDbgPostTraceValue(DWORD dwTraceValue_p);
EPLDLLEXPORT DWORD PUBLIC EplIdentuGetRunningRequests(void); EPLDLLEXPORT DWORD EplIdentuGetRunningRequests(void);
//=========================================================================// //=========================================================================//
// // // //
@ -191,7 +191,7 @@ tEplKernel EplLinProcFree(void)
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#ifdef _DBG_TRACE_POINTS_ #ifdef _DBG_TRACE_POINTS_
void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p) void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p)
{ {
if (bTracePointNumber_p >= if (bTracePointNumber_p >=
@ -207,7 +207,7 @@ void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p)
} }
void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p) void TgtDbgPostTraceValue(DWORD dwTraceValue_p)
{ {
spin_lock_irqsave(&spinlockDbgTraceValue_l, ulDbTraceValueFlags_l); spin_lock_irqsave(&spinlockDbgTraceValue_l, ulDbTraceValueFlags_l);

47
drivers/staging/epl/user/EplCfgMau.h
View File

@ -86,8 +86,8 @@
#define EPL_CFGMA_MAX_TIMEOUT 3 #define EPL_CFGMA_MAX_TIMEOUT 3
//callbackfunction, called if configuration is finished //callbackfunction, called if configuration is finished
typedef void (PUBLIC * tfpEplCfgMaCb) (unsigned int uiNodeId_p, typedef void (* tfpEplCfgMaCb)(unsigned int uiNodeId_p,
tEplKernel Errorstate_p); tEplKernel Errorstate_p);
//State for configuartion manager Statemachine //State for configuartion manager Statemachine
typedef enum { typedef enum {
@ -166,7 +166,7 @@ typedef struct {
// //
// Returns: tEplKernel = error code // Returns: tEplKernel = error code
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplCfgMaInit(); tEplKernel EplCfgMaInit(void);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// Function: EplCfgMaAddInstance() // Function: EplCfgMaAddInstance()
@ -177,7 +177,7 @@ tEplKernel PUBLIC EplCfgMaInit();
// //
// Returns: tEplKernel = error code // Returns: tEplKernel = error code
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplCfgMaAddInstance(); tEplKernel EplCfgMaAddInstance(void);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// Function: EplCfgMaDelInstance() // Function: EplCfgMaDelInstance()
@ -188,7 +188,7 @@ tEplKernel PUBLIC EplCfgMaAddInstance();
// //
// Returns: tEplKernel = error code // Returns: tEplKernel = error code
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplCfgMaDelInstance(); tEplKernel plCfgMaDelInstance(void);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// Function: EplCfgMaStartConfig() // Function: EplCfgMaStartConfig()
@ -204,11 +204,11 @@ tEplKernel PUBLIC EplCfgMaDelInstance();
// //
// Returns: tCopKernel = error code // Returns: tCopKernel = error code
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplCfgMaStartConfig(unsigned int uiNodeId_p, tEplKernel EplCfgMaStartConfig(unsigned int uiNodeId_p,
BYTE * pbConcise_p, BYTE * pbConcise_p,
tfpEplCfgMaCb fpCfgMaCb_p, tfpEplCfgMaCb fpCfgMaCb_p,
tEplObdSize SizeOfConcise_p, tEplObdSize SizeOfConcise_p,
tEplCfgMaDcfTyp DcfType_p); tEplCfgMaDcfTyp DcfType_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// Function: CfgMaStartConfigurationNode() // Function: CfgMaStartConfigurationNode()
@ -222,9 +222,9 @@ tEplKernel PUBLIC EplCfgMaStartConfig(unsigned int uiNodeId_p,
// //
// Returns: tCopKernel = error code // Returns: tCopKernel = error code
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplCfgMaStartConfigNode(unsigned int uiNodeId_p, tEplKernel EplCfgMaStartConfigNode(unsigned int uiNodeId_p,
tfpEplCfgMaCb fpCfgMaCb_p, tfpEplCfgMaCb fpCfgMaCb_p,
tEplCfgMaDcfTyp DcfType_p); tEplCfgMaDcfTyp DcfType_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// Function: EplCfgMaStartConfigNodeDcf() // Function: EplCfgMaStartConfigNodeDcf()
@ -240,11 +240,11 @@ tEplKernel PUBLIC EplCfgMaStartConfigNode(unsigned int uiNodeId_p,
// //
// Returns: tCopKernel = error code // Returns: tCopKernel = error code
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplCfgMaStartConfigNodeDcf(unsigned int uiNodeId_p, tEplKernel EplCfgMaStartConfigNodeDcf(unsigned int uiNodeId_p,
BYTE * pbConcise_p, BYTE * pbConcise_p,
tfpEplCfgMaCb fpCfgMaCb_p, tfpEplCfgMaCb fpCfgMaCb_p,
tEplObdSize SizeOfConcise_p, tEplObdSize SizeOfConcise_p,
tEplCfgMaDcfTyp DcfType_p); tEplCfgMaDcfTyp DcfType_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// Function: EplCfgMaLinkDcf() // Function: EplCfgMaLinkDcf()
@ -258,10 +258,10 @@ tEplKernel PUBLIC EplCfgMaStartConfigNodeDcf(unsigned int uiNodeId_p,
// //
// Returns: tCopKernel = error code // Returns: tCopKernel = error code
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplCfgMaLinkDcf(unsigned int uiNodeId_p, tEplKernel EplCfgMaLinkDcf(unsigned int uiNodeId_p,
BYTE * pbConcise_p, BYTE * pbConcise_p,
tEplObdSize SizeOfConcise_p, tEplObdSize SizeOfConcise_p,
tEplCfgMaDcfTyp DcfType_p); tEplCfgMaDcfTyp DcfType_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// Function: EplCfgMaCheckDcf() // Function: EplCfgMaCheckDcf()
@ -274,8 +274,7 @@ tEplKernel PUBLIC EplCfgMaLinkDcf(unsigned int uiNodeId_p,
// //
// Returns: tCopKernel = error code // Returns: tCopKernel = error code
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplCfgMaCheckDcf(unsigned int uiNodeId_p, tEplKernel EplCfgMaCheckDcf(unsigned int uiNodeId_p, tEplCfgMaDcfTyp DcfType_p);
tEplCfgMaDcfTyp DcfType_p);
#endif // #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_CFGMA)) != 0) #endif // #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_CFGMA)) != 0)

2
drivers/staging/epl/user/EplDllu.h
View File

@ -81,7 +81,7 @@
// typedef // typedef
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
typedef tEplKernel(PUBLIC * tEplDlluCbAsnd) (tEplFrameInfo * pFrameInfo_p); typedef tEplKernel(* tEplDlluCbAsnd) (tEplFrameInfo * pFrameInfo_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// function prototypes // function prototypes

2
drivers/staging/epl/user/EplDlluCal.h
View File

@ -82,7 +82,7 @@
// typedef // typedef
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
typedef tEplKernel(PUBLIC * tEplDlluCbAsnd) (tEplFrameInfo * pFrameInfo_p); typedef tEplKernel(* tEplDlluCbAsnd) (tEplFrameInfo * pFrameInfo_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// function prototypes // function prototypes

17
drivers/staging/epl/user/EplEventu.h
View File

@ -85,24 +85,23 @@
// function prototypes // function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// init function // init function
tEplKernel PUBLIC EplEventuInit(tEplProcessEventCb pfnApiProcessEventCb_p); tEplKernel EplEventuInit(tEplProcessEventCb pfnApiProcessEventCb_p);
// add instance // add instance
tEplKernel PUBLIC EplEventuAddInstance(tEplProcessEventCb tEplKernel EplEventuAddInstance(tEplProcessEventCb pfnApiProcessEventCb_p);
pfnApiProcessEventCb_p);
// delete instance // delete instance
tEplKernel PUBLIC EplEventuDelInstance(void); tEplKernel EplEventuDelInstance(void);
// Task that dispatches events in userspace // Task that dispatches events in userspace
tEplKernel PUBLIC EplEventuProcess(tEplEvent * pEvent_p); tEplKernel EplEventuProcess(tEplEvent * pEvent_p);
// post events from userspace // post events from userspace
tEplKernel PUBLIC EplEventuPost(tEplEvent * pEvent_p); tEplKernel EplEventuPost(tEplEvent * pEvent_p);
// post errorevents from userspace // post errorevents from userspace
tEplKernel PUBLIC EplEventuPostError(tEplEventSource EventSource_p, tEplKernel EplEventuPostError(tEplEventSource EventSource_p,
tEplKernel EplError_p, tEplKernel EplError_p,
unsigned int uiArgSize_p, void *pArg_p); unsigned int uiArgSize_p, void *pArg_p);
#endif // #ifndef _EPL_EVENTU_H_ #endif // #ifndef _EPL_EVENTU_H_

20
drivers/staging/epl/user/EplIdentu.h
View File

@ -81,7 +81,7 @@
// typedef // typedef
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
typedef tEplKernel(PUBLIC * tEplIdentuCbResponse) (unsigned int uiNodeId_p, typedef tEplKernel(* tEplIdentuCbResponse) (unsigned int uiNodeId_p,
tEplIdentResponse * tEplIdentResponse *
pIdentResponse_p); pIdentResponse_p);
@ -89,20 +89,18 @@ typedef tEplKernel(PUBLIC * tEplIdentuCbResponse) (unsigned int uiNodeId_p,
// function prototypes // function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplIdentuInit(void); tEplKernel EplIdentuInit(void);
tEplKernel PUBLIC EplIdentuAddInstance(void); tEplKernel EplIdentuAddInstance(void);
tEplKernel PUBLIC EplIdentuDelInstance(void); tEplKernel EplIdentuDelInstance(void);
tEplKernel PUBLIC EplIdentuReset(void); tEplKernel EplIdentuReset(void);
tEplKernel PUBLIC EplIdentuGetIdentResponse(unsigned int uiNodeId_p, tEplKernel EplIdentuGetIdentResponse(unsigned int uiNodeId_p,
tEplIdentResponse ** tEplIdentResponse **ppIdentResponse_p);
ppIdentResponse_p);
tEplKernel PUBLIC EplIdentuRequestIdentResponse(unsigned int uiNodeId_p, tEplKernel EplIdentuRequestIdentResponse(unsigned int uiNodeId_p,
tEplIdentuCbResponse tEplIdentuCbResponse pfnCbResponse_p);
pfnCbResponse_p);
#endif // #ifndef _EPLIDENTU_H_ #endif // #ifndef _EPLIDENTU_H_

14
drivers/staging/epl/user/EplLedu.h
View File

@ -83,7 +83,7 @@
// typedef // typedef
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
typedef tEplKernel(PUBLIC * tEplLeduStateChangeCallback) (tEplLedType LedType_p, typedef tEplKernel(* tEplLeduStateChangeCallback) (tEplLedType LedType_p,
BOOL fOn_p); BOOL fOn_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -92,17 +92,15 @@ typedef tEplKernel(PUBLIC * tEplLeduStateChangeCallback) (tEplLedType LedType_p,
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0) #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0)
tEplKernel PUBLIC EplLeduInit(tEplLeduStateChangeCallback pfnCbStateChange_p); tEplKernel EplLeduInit(tEplLeduStateChangeCallback pfnCbStateChange_p);
tEplKernel PUBLIC EplLeduAddInstance(tEplLeduStateChangeCallback tEplKernel EplLeduAddInstance(tEplLeduStateChangeCallback pfnCbStateChange_p);
pfnCbStateChange_p);
tEplKernel PUBLIC EplLeduDelInstance(void); tEplKernel EplLeduDelInstance(void);
tEplKernel PUBLIC EplLeduCbNmtStateChange(tEplEventNmtStateChange tEplKernel EplLeduCbNmtStateChange(tEplEventNmtStateChange NmtStateChange_p);
NmtStateChange_p);
tEplKernel PUBLIC EplLeduProcessEvent(tEplEvent * pEplEvent_p); tEplKernel EplLeduProcessEvent(tEplEvent * pEplEvent_p);
#endif // #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0) #endif // #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0)

13
drivers/staging/epl/user/EplNmtCnu.h
View File

@ -89,17 +89,16 @@
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_CN)) != 0) #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_CN)) != 0)
EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuInit(unsigned int uiNodeId_p); EPLDLLEXPORT tEplKernel EplNmtCnuInit(unsigned int uiNodeId_p);
EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuAddInstance(unsigned int uiNodeId_p); EPLDLLEXPORT tEplKernel EplNmtCnuAddInstance(unsigned int uiNodeId_p);
EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuDelInstance(void); EPLDLLEXPORT tEplKernel EplNmtCnuDelInstance(void);
EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuSendNmtRequest(unsigned int uiNodeId_p, EPLDLLEXPORT tEplKernel EplNmtCnuSendNmtRequest(unsigned int uiNodeId_p,
tEplNmtCommand tEplNmtCommand NmtCommand_p);
NmtCommand_p);
EPLDLLEXPORT tEplKernel PUBLIC EPLDLLEXPORT tEplKernel
EplNmtCnuRegisterCheckEventCb(tEplNmtuCheckEventCallback EplNmtCnuRegisterCheckEventCb(tEplNmtuCheckEventCallback
pfnEplNmtCheckEventCb_p); pfnEplNmtCheckEventCb_p);

26
drivers/staging/epl/user/EplNmtMnu.h
View File

@ -81,17 +81,15 @@
// typedef // typedef
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
typedef tEplKernel(PUBLIC * tEplNmtMnuCbNodeEvent) (unsigned int uiNodeId_p, typedef tEplKernel(* tEplNmtMnuCbNodeEvent) (unsigned int uiNodeId_p,
tEplNmtNodeEvent tEplNmtNodeEvent NodeEvent_p,
NodeEvent_p, tEplNmtState NmtState_p,
tEplNmtState NmtState_p, WORD wErrorCode_p,
WORD wErrorCode_p, BOOL fMandatory_p);
BOOL fMandatory_p);
typedef tEplKernel(PUBLIC * typedef tEplKernel(* tEplNmtMnuCbBootEvent) (tEplNmtBootEvent BootEvent_p,
tEplNmtMnuCbBootEvent) (tEplNmtBootEvent BootEvent_p, tEplNmtState NmtState_p,
tEplNmtState NmtState_p, WORD wErrorCode_p);
WORD wErrorCode_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// function prototypes // function prototypes
@ -107,7 +105,7 @@ tEplKernel EplNmtMnuAddInstance(tEplNmtMnuCbNodeEvent pfnCbNodeEvent_p,
tEplKernel EplNmtMnuDelInstance(void); tEplKernel EplNmtMnuDelInstance(void);
EPLDLLEXPORT tEplKernel PUBLIC EplNmtMnuProcessEvent(tEplEvent * pEvent_p); EPLDLLEXPORT tEplKernel EplNmtMnuProcessEvent(tEplEvent * pEvent_p);
tEplKernel EplNmtMnuSendNmtCommand(unsigned int uiNodeId_p, tEplKernel EplNmtMnuSendNmtCommand(unsigned int uiNodeId_p,
tEplNmtCommand NmtCommand_p); tEplNmtCommand NmtCommand_p);
@ -115,12 +113,12 @@ tEplKernel EplNmtMnuSendNmtCommand(unsigned int uiNodeId_p,
tEplKernel EplNmtMnuTriggerStateChange(unsigned int uiNodeId_p, tEplKernel EplNmtMnuTriggerStateChange(unsigned int uiNodeId_p,
tEplNmtNodeCommand NodeCommand_p); tEplNmtNodeCommand NodeCommand_p);
tEplKernel PUBLIC EplNmtMnuCbNmtStateChange(tEplEventNmtStateChange tEplKernel EplNmtMnuCbNmtStateChange(tEplEventNmtStateChange
NmtStateChange_p); NmtStateChange_p);
tEplKernel PUBLIC EplNmtMnuCbCheckEvent(tEplNmtEvent NmtEvent_p); tEplKernel EplNmtMnuCbCheckEvent(tEplNmtEvent NmtEvent_p);
tEplKernel PUBLIC EplNmtMnuGetDiagnosticInfo(unsigned int tEplKernel EplNmtMnuGetDiagnosticInfo(unsigned int
*puiMandatorySlaveCount_p, *puiMandatorySlaveCount_p,
unsigned int unsigned int
*puiSignalSlaveCount_p, *puiSignalSlaveCount_p,

23
drivers/staging/epl/user/EplNmtu.h
View File

@ -121,12 +121,9 @@ typedef enum {
kEplNmtCmdInvalidService = 0xFF kEplNmtCmdInvalidService = 0xFF
} tEplNmtCommand; } tEplNmtCommand;
typedef tEplKernel(PUBLIC * typedef tEplKernel(* tEplNmtuStateChangeCallback) (tEplEventNmtStateChange NmtStateChange_p);
tEplNmtuStateChangeCallback) (tEplEventNmtStateChange
NmtStateChange_p);
typedef tEplKernel(PUBLIC * typedef tEplKernel(* tEplNmtuCheckEventCallback) (tEplNmtEvent NmtEvent_p);
tEplNmtuCheckEventCallback) (tEplNmtEvent NmtEvent_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// function prototypes // function prototypes
@ -134,21 +131,19 @@ typedef tEplKernel(PUBLIC *
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0) #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0)
EPLDLLEXPORT tEplKernel PUBLIC EplNmtuInit(void); EPLDLLEXPORT tEplKernel EplNmtuInit(void);
EPLDLLEXPORT tEplKernel PUBLIC EplNmtuAddInstance(void); EPLDLLEXPORT tEplKernel EplNmtuAddInstance(void);
EPLDLLEXPORT tEplKernel PUBLIC EplNmtuDelInstance(void); EPLDLLEXPORT tEplKernel EplNmtuDelInstance(void);
EPLDLLEXPORT tEplKernel PUBLIC EplNmtuNmtEvent(tEplNmtEvent NmtEvent_p); EPLDLLEXPORT tEplKernel EplNmtuNmtEvent(tEplNmtEvent NmtEvent_p);
EPLDLLEXPORT tEplNmtState PUBLIC EplNmtuGetNmtState(void); EPLDLLEXPORT tEplNmtState EplNmtuGetNmtState(void);
EPLDLLEXPORT tEplKernel PUBLIC EplNmtuProcessEvent(tEplEvent * pEplEvent_p); EPLDLLEXPORT tEplKernel EplNmtuProcessEvent(tEplEvent * pEplEvent_p);
EPLDLLEXPORT tEplKernel PUBLIC EPLDLLEXPORT tEplKernel EplNmtuRegisterStateChangeCb(tEplNmtuStateChangeCallback pfnEplNmtStateChangeCb_p);
EplNmtuRegisterStateChangeCb(tEplNmtuStateChangeCallback
pfnEplNmtStateChangeCb_p);
#endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0) #endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0)

2
drivers/staging/epl/user/EplNmtuCal.h
View File

@ -86,6 +86,6 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// function prototypes // function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplNmtState PUBLIC EplNmtkCalGetNmtState(void); EPLDLLEXPORT tEplNmtState EplNmtkCalGetNmtState(void);
#endif // #ifndef _EPLNMTUCAL_H_ #endif // #ifndef _EPLNMTUCAL_H_

110
drivers/staging/epl/user/EplObdu.h
View File

@ -91,68 +91,64 @@
#error "EPL OBDu module enabled, but OBD_USE_KERNEL == TRUE" #error "EPL OBDu module enabled, but OBD_USE_KERNEL == TRUE"
#endif #endif
EPLDLLEXPORT tEplKernel PUBLIC EplObduWriteEntry(unsigned int uiIndex_p, EPLDLLEXPORT tEplKernel EplObduWriteEntry(unsigned int uiIndex_p,
unsigned int uiSubIndex_p, unsigned int uiSubIndex_p,
void *pSrcData_p, void *pSrcData_p,
tEplObdSize Size_p); tEplObdSize Size_p);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduReadEntry(unsigned int uiIndex_p, EPLDLLEXPORT tEplKernel EplObduReadEntry(unsigned int uiIndex_p,
unsigned int uiSubIndex_p,
void *pDstData_p,
tEplObdSize *pSize_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduAccessOdPart(tEplObdPart ObdPart_p,
tEplObdDir Direction_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduDefineVar(tEplVarParam MEM * pVarParam_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT void *EplObduGetObjectDataPtr(unsigned int uiIndex_p,
unsigned int uiSubIndex_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduRegisterUserOd(tEplObdEntryPtr pUserOd_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT void EplObduInitVarEntry(tEplObdVarEntry MEM * pVarEntry_p,
BYTE bType_p, tEplObdSize ObdSize_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplObdSize EplObduGetDataSize(unsigned int uiIndex_p,
unsigned int uiSubIndex_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT unsigned int EplObduGetNodeId(void);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduSetNodeId(unsigned int uiNodeId_p,
tEplObdNodeIdType NodeIdType_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduGetAccessType(unsigned int uiIndex_p,
unsigned int uiSubIndex_p,
tEplObdAccess *pAccessTyp_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduReadEntryToLe(unsigned int uiIndex_p,
unsigned int uiSubIndex_p,
void *pDstData_p,
tEplObdSize *pSize_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduWriteEntryFromLe(unsigned int uiIndex_p,
unsigned int uiSubIndex_p, unsigned int uiSubIndex_p,
void *pDstData_p, void *pSrcData_p,
tEplObdSize * pSize_p); tEplObdSize Size_p);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduAccessOdPart(tEplObdPart ObdPart_p, EPLDLLEXPORT tEplKernel EplObduSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_
tEplObdDir Direction_p); unsigned int uiIndex_p,
unsigned int uiSubindex_p,
// --------------------------------------------------------------------- tEplObdVarEntry MEM **ppVarEntry_p);
EPLDLLEXPORT tEplKernel PUBLIC EplObduDefineVar(tEplVarParam MEM * pVarParam_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT void *PUBLIC EplObduGetObjectDataPtr(unsigned int uiIndex_p,
unsigned int uiSubIndex_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduRegisterUserOd(tEplObdEntryPtr pUserOd_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT void PUBLIC EplObduInitVarEntry(tEplObdVarEntry MEM * pVarEntry_p,
BYTE bType_p,
tEplObdSize ObdSize_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplObdSize PUBLIC EplObduGetDataSize(unsigned int uiIndex_p,
unsigned int uiSubIndex_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT unsigned int PUBLIC EplObduGetNodeId(void);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduSetNodeId(unsigned int uiNodeId_p,
tEplObdNodeIdType NodeIdType_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduGetAccessType(unsigned int uiIndex_p,
unsigned int uiSubIndex_p,
tEplObdAccess *
pAccessTyp_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduReadEntryToLe(unsigned int uiIndex_p,
unsigned int uiSubIndex_p,
void *pDstData_p,
tEplObdSize * pSize_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduWriteEntryFromLe(unsigned int uiIndex_p,
unsigned int
uiSubIndex_p,
void *pSrcData_p,
tEplObdSize Size_p);
// ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_
unsigned int uiIndex_p,
unsigned int uiSubindex_p,
tEplObdVarEntry MEM **
ppVarEntry_p);
#elif EPL_OBD_USE_KERNEL != FALSE #elif EPL_OBD_USE_KERNEL != FALSE
#include "../kernel/EplObdk.h" #include "../kernel/EplObdk.h"

96
drivers/staging/epl/user/EplObduCal.h
View File

@ -85,62 +85,52 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// function prototypes // function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduCalWriteEntry(unsigned int uiIndex_p, EPLDLLEXPORT tEplKernel EplObduCalWriteEntry(unsigned int uiIndex_p,
unsigned int uiSubIndex_p, unsigned int uiSubIndex_p,
void *pSrcData_p, void *pSrcData_p,
tEplObdSize Size_p); tEplObdSize Size_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduCalReadEntry(unsigned int uiIndex_p, EPLDLLEXPORT tEplKernel EplObduCalReadEntry(unsigned int uiIndex_p,
unsigned int uiSubIndex_p,
void *pDstData_p,
tEplObdSize * pSize_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduCalAccessOdPart(tEplObdPart ObdPart_p,
tEplObdDir Direction_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduCalDefineVar(tEplVarParam MEM *pVarParam_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT void *EplObduCalGetObjectDataPtr(unsigned int uiIndex_p,
unsigned int uiSubIndex_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduCalRegisterUserOd(tEplObdEntryPtr pUserOd_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT void EplObduCalInitVarEntry(tEplObdVarEntry MEM *pVarEntry_p,
BYTE bType_p, tEplObdSize ObdSize_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplObdSize EplObduCalGetDataSize(unsigned int uiIndex_p,
unsigned int uiSubIndex_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT unsigned int EplObduCalGetNodeId(void);
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduCalSetNodeId(unsigned int uiNodeId_p,
tEplObdNodeIdType NodeIdType_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduCalGetAccessType(unsigned int uiIndex_p,
unsigned int uiSubIndex_p,
tEplObdAccess *pAccessTyp_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduCalReadEntryToLe(unsigned int uiIndex_p,
unsigned int uiSubIndex_p,
void *pDstData_p,
tEplObdSize *pSize_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduCalWriteEntryFromLe(unsigned int uiIndex_p,
unsigned int uiSubIndex_p, unsigned int uiSubIndex_p,
void *pDstData_p, void *pSrcData_p,
tEplObdSize * pSize_p); tEplObdSize Size_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduCalAccessOdPart(tEplObdPart ObdPart_p, EPLDLLEXPORT tEplKernel
tEplObdDir Direction_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduCalDefineVar(tEplVarParam MEM *
pVarParam_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT void *PUBLIC EplObduCalGetObjectDataPtr(unsigned int uiIndex_p,
unsigned int uiSubIndex_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduCalRegisterUserOd(tEplObdEntryPtr
pUserOd_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT void PUBLIC EplObduCalInitVarEntry(tEplObdVarEntry MEM *
pVarEntry_p, BYTE bType_p,
tEplObdSize ObdSize_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplObdSize PUBLIC EplObduCalGetDataSize(unsigned int uiIndex_p,
unsigned int
uiSubIndex_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT unsigned int PUBLIC EplObduCalGetNodeId(void);
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduCalSetNodeId(unsigned int uiNodeId_p,
tEplObdNodeIdType
NodeIdType_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduCalGetAccessType(unsigned int uiIndex_p,
unsigned int
uiSubIndex_p,
tEplObdAccess *
pAccessTyp_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduCalReadEntryToLe(unsigned int uiIndex_p,
unsigned int
uiSubIndex_p,
void *pDstData_p,
tEplObdSize * pSize_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObduCalWriteEntryFromLe(unsigned int
uiIndex_p,
unsigned int
uiSubIndex_p,
void *pSrcData_p,
tEplObdSize Size_p);
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC
EplObduCalSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p, EplObduCalSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiSubindex_p, unsigned int uiSubindex_p,
tEplObdVarEntry MEM ** ppVarEntry_p); tEplObdVarEntry MEM ** ppVarEntry_p);

2
drivers/staging/epl/user/EplPdou.h
View File

@ -89,7 +89,7 @@ tEplKernel EplPdouAddInstance(void);
tEplKernel EplPdouDelInstance(void); tEplKernel EplPdouDelInstance(void);
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOU)) != 0) #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOU)) != 0)
tEplKernel PUBLIC EplPdouCbObdAccess(tEplObdCbParam MEM * pParam_p); tEplKernel EplPdouCbObdAccess(tEplObdCbParam MEM * pParam_p);
#else #else
#define EplPdouCbObdAccess NULL #define EplPdouCbObdAccess NULL
#endif #endif

18
drivers/staging/epl/user/EplSdoAsndu.h
View File

@ -87,20 +87,20 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDO_ASND)) != 0) #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDO_ASND)) != 0)
tEplKernel PUBLIC EplSdoAsnduInit(tEplSequLayerReceiveCb fpReceiveCb_p); tEplKernel EplSdoAsnduInit(tEplSequLayerReceiveCb fpReceiveCb_p);
tEplKernel PUBLIC EplSdoAsnduAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p); tEplKernel EplSdoAsnduAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p);
tEplKernel PUBLIC EplSdoAsnduDelInstance(void); tEplKernel EplSdoAsnduDelInstance(void);
tEplKernel PUBLIC EplSdoAsnduInitCon(tEplSdoConHdl * pSdoConHandle_p, tEplKernel EplSdoAsnduInitCon(tEplSdoConHdl *pSdoConHandle_p,
unsigned int uiTargetNodeId_p); unsigned int uiTargetNodeId_p);
tEplKernel PUBLIC EplSdoAsnduSendData(tEplSdoConHdl SdoConHandle_p, tEplKernel EplSdoAsnduSendData(tEplSdoConHdl SdoConHandle_p,
tEplFrame * pSrcData_p, tEplFrame *pSrcData_p,
DWORD dwDataSize_p); DWORD dwDataSize_p);
tEplKernel PUBLIC EplSdoAsnduDelCon(tEplSdoConHdl SdoConHandle_p); tEplKernel EplSdoAsnduDelCon(tEplSdoConHdl SdoConHandle_p);
#endif // end of #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDO_ASND)) != 0) #endif // end of #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDO_ASND)) != 0)

26
drivers/staging/epl/user/EplSdoAsySequ.h
View File

@ -88,24 +88,24 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// function prototypes // function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoAsySeqInit(tEplSdoComReceiveCb fpSdoComCb_p, tEplKernel EplSdoAsySeqInit(tEplSdoComReceiveCb fpSdoComCb_p,
tEplSdoComConCb fpSdoComConCb_p);
tEplKernel EplSdoAsySeqAddInstance(tEplSdoComReceiveCb fpSdoComCb_p,
tEplSdoComConCb fpSdoComConCb_p); tEplSdoComConCb fpSdoComConCb_p);
tEplKernel PUBLIC EplSdoAsySeqAddInstance(tEplSdoComReceiveCb fpSdoComCb_p, tEplKernel EplSdoAsySeqDelInstance(void);
tEplSdoComConCb fpSdoComConCb_p);
tEplKernel PUBLIC EplSdoAsySeqDelInstance(void); tEplKernel EplSdoAsySeqInitCon(tEplSdoSeqConHdl *pSdoSeqConHdl_p,
unsigned int uiNodeId_p,
tEplSdoType SdoType);
tEplKernel PUBLIC EplSdoAsySeqInitCon(tEplSdoSeqConHdl * pSdoSeqConHdl_p, tEplKernel EplSdoAsySeqSendData(tEplSdoSeqConHdl SdoSeqConHdl_p,
unsigned int uiNodeId_p, unsigned int uiDataSize_p,
tEplSdoType SdoType); tEplFrame *pData_p);
tEplKernel PUBLIC EplSdoAsySeqSendData(tEplSdoSeqConHdl SdoSeqConHdl_p, tEplKernel EplSdoAsySeqProcessEvent(tEplEvent *pEvent_p);
unsigned int uiDataSize_p,
tEplFrame * pData_p);
tEplKernel PUBLIC EplSdoAsySeqProcessEvent(tEplEvent * pEvent_p); tEplKernel EplSdoAsySeqDelCon(tEplSdoSeqConHdl SdoSeqConHdl_p);
tEplKernel PUBLIC EplSdoAsySeqDelCon(tEplSdoSeqConHdl SdoSeqConHdl_p);
#endif // #ifndef _EPLSDOASYSEQU_H_ #endif // #ifndef _EPLSDOASYSEQU_H_

31
drivers/staging/epl/user/EplSdoComu.h
View File

@ -88,38 +88,37 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// function prototypes // function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplSdoComInit(void); tEplKernel EplSdoComInit(void);
tEplKernel PUBLIC EplSdoComAddInstance(void); tEplKernel EplSdoComAddInstance(void);
tEplKernel PUBLIC EplSdoComDelInstance(void); tEplKernel EplSdoComDelInstance(void);
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0) #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
tEplKernel PUBLIC EplSdoComDefineCon(tEplSdoComConHdl * pSdoComConHdl_p, tEplKernel EplSdoComDefineCon(tEplSdoComConHdl *pSdoComConHdl_p,
unsigned int uiTargetNodeId_p, unsigned int uiTargetNodeId_p,
tEplSdoType ProtType_p); tEplSdoType ProtType_p);
tEplKernel PUBLIC EplSdoComInitTransferByIndex(tEplSdoComTransParamByIndex * tEplKernel EplSdoComInitTransferByIndex(tEplSdoComTransParamByIndex *pSdoComTransParam_p);
pSdoComTransParam_p);
tEplKernel PUBLIC EplSdoComUndefineCon(tEplSdoComConHdl SdoComConHdl_p); tEplKernel EplSdoComUndefineCon(tEplSdoComConHdl SdoComConHdl_p);
tEplKernel PUBLIC EplSdoComGetState(tEplSdoComConHdl SdoComConHdl_p, tEplKernel EplSdoComGetState(tEplSdoComConHdl SdoComConHdl_p,
tEplSdoComFinished * pSdoComFinished_p); tEplSdoComFinished *pSdoComFinished_p);
tEplKernel PUBLIC EplSdoComSdoAbort(tEplSdoComConHdl SdoComConHdl_p, tEplKernel EplSdoComSdoAbort(tEplSdoComConHdl SdoComConHdl_p,
DWORD dwAbortCode_p); DWORD dwAbortCode_p);
#endif #endif
// for future extention // for future extention
/* /*
tEplKernel PUBLIC EplSdoComInitTransferAllByIndex(tEplSdoComTransParamAllByIndex* pSdoComTransParam_p); tEplKernel EplSdoComInitTransferAllByIndex(tEplSdoComTransParamAllByIndex* pSdoComTransParam_p);
tEplKernel PUBLIC EplSdoComInitTransferByName(tEplSdoComTransParamByName* pSdoComTransParam_p); tEplKernel EplSdoComInitTransferByName(tEplSdoComTransParamByName* pSdoComTransParam_p);
tEplKernel PUBLIC EplSdoComInitTransferFile(tEplSdoComTransParamFile* pSdoComTransParam_p); tEplKernel EplSdoComInitTransferFile(tEplSdoComTransParamFile* pSdoComTransParam_p);
*/ */

21
drivers/staging/epl/user/EplSdoUdpu.h
View File

@ -86,23 +86,22 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDO_UDP)) != 0) #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDO_UDP)) != 0)
tEplKernel PUBLIC EplSdoUdpuInit(tEplSequLayerReceiveCb fpReceiveCb_p); tEplKernel EplSdoUdpuInit(tEplSequLayerReceiveCb fpReceiveCb_p);
tEplKernel PUBLIC EplSdoUdpuAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p); tEplKernel EplSdoUdpuAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p);
tEplKernel PUBLIC EplSdoUdpuDelInstance(void); tEplKernel EplSdoUdpuDelInstance(void);
tEplKernel PUBLIC EplSdoUdpuConfig(unsigned long ulIpAddr_p, tEplKernel EplSdoUdpuConfig(unsigned long ulIpAddr_p,
unsigned int uiPort_p); unsigned int uiPort_p);
tEplKernel PUBLIC EplSdoUdpuInitCon(tEplSdoConHdl * pSdoConHandle_p, tEplKernel EplSdoUdpuInitCon(tEplSdoConHdl *pSdoConHandle_p,
unsigned int uiTargetNodeId_p); unsigned int uiTargetNodeId_p);
tEplKernel PUBLIC EplSdoUdpuSendData(tEplSdoConHdl SdoConHandle_p, tEplKernel EplSdoUdpuSendData(tEplSdoConHdl SdoConHandle_p,
tEplFrame * pSrcData_p, tEplFrame *pSrcData_p, DWORD dwDataSize_p);
DWORD dwDataSize_p);
tEplKernel PUBLIC EplSdoUdpuDelCon(tEplSdoConHdl SdoConHandle_p); tEplKernel EplSdoUdpuDelCon(tEplSdoConHdl SdoConHandle_p);
#endif // end of #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDO_UDP)) != 0) #endif // end of #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDO_UDP)) != 0)

18
drivers/staging/epl/user/EplStatusu.h
View File

@ -81,24 +81,22 @@
// typedef // typedef
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
typedef tEplKernel(PUBLIC * tEplStatusuCbResponse) (unsigned int uiNodeId_p, typedef tEplKernel(* tEplStatusuCbResponse) (unsigned int uiNodeId_p,
tEplStatusResponse * tEplStatusResponse *pStatusResponse_p);
pStatusResponse_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// function prototypes // function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplStatusuInit(void); tEplKernel EplStatusuInit(void);
tEplKernel PUBLIC EplStatusuAddInstance(void); tEplKernel EplStatusuAddInstance(void);
tEplKernel PUBLIC EplStatusuDelInstance(void); tEplKernel EplStatusuDelInstance(void);
tEplKernel PUBLIC EplStatusuReset(void); tEplKernel EplStatusuReset(void);
tEplKernel PUBLIC EplStatusuRequestStatusResponse(unsigned int uiNodeId_p, tEplKernel EplStatusuRequestStatusResponse(unsigned int uiNodeId_p,
tEplStatusuCbResponse tEplStatusuCbResponse pfnCbResponse_p);
pfnCbResponse_p);
#endif // #ifndef _EPLSTATUSU_H_ #endif // #ifndef _EPLSTATUSU_H_

22
drivers/staging/epl/user/EplTimeru.h
View File

@ -86,22 +86,22 @@
// function prototypes // function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel PUBLIC EplTimeruInit(void); tEplKernel EplTimeruInit(void);
tEplKernel PUBLIC EplTimeruAddInstance(void); tEplKernel EplTimeruAddInstance(void);
tEplKernel PUBLIC EplTimeruDelInstance(void); tEplKernel EplTimeruDelInstance(void);
tEplKernel PUBLIC EplTimeruSetTimerMs(tEplTimerHdl * pTimerHdl_p, tEplKernel EplTimeruSetTimerMs(tEplTimerHdl *pTimerHdl_p,
unsigned long ulTime_p, unsigned long ulTime_p,
tEplTimerArg Argument_p); tEplTimerArg Argument_p);
tEplKernel PUBLIC EplTimeruModifyTimerMs(tEplTimerHdl * pTimerHdl_p, tEplKernel EplTimeruModifyTimerMs(tEplTimerHdl *pTimerHdl_p,
unsigned long ulTime_p, unsigned long ulTime_p,
tEplTimerArg Argument_p); tEplTimerArg Argument_p);
tEplKernel PUBLIC EplTimeruDeleteTimer(tEplTimerHdl * pTimerHdl_p); tEplKernel EplTimeruDeleteTimer(tEplTimerHdl *pTimerHdl_p);
BOOL PUBLIC EplTimeruIsTimerActive(tEplTimerHdl TimerHdl_p); BOOL EplTimeruIsTimerActive(tEplTimerHdl TimerHdl_p);
#endif // #ifndef _EPLTIMERU_H_ #endif // #ifndef _EPLTIMERU_H_