android/android_kernel_xiaomi_sm8450
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Staging: epl: remove MEM

Browse Source 
It's not used and is not needed.

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 12:09:26 -07:00
parent 5318487c34
commit 5e9f6bc67d
17 changed files with 151 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -634,13 +634,13 @@
extern "C" { extern "C" {
#endif #endif
void DumpData(char *szStr_p, BYTE MEM * pbData_p, WORD wSize_p); void DumpData(char *szStr_p, BYTE *pbData_p, WORD wSize_p);
#ifdef __cplusplus #ifdef __cplusplus
} // von extern "C" } // von extern "C"
#endif #endif
#define DEBUG_DUMP_DATA(lvl,str,ptr,siz) if ((DEBUG_GLB_LVL() & (lvl))==(lvl)) \ #define DEBUG_DUMP_DATA(lvl,str,ptr,siz) if ((DEBUG_GLB_LVL() & (lvl))==(lvl)) \
DumpData (str, (BYTE MEM*) (ptr), (WORD) (siz)); DumpData (str, (BYTE *)(ptr), (WORD)(siz));
#else #else
#define DEBUG_DUMP_DATA(lvl,str,ptr,siz) #define DEBUG_DUMP_DATA(lvl,str,ptr,siz)

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

@ -244,7 +244,7 @@ tEplKernel EplApiWriteLocalObject(unsigned int uiIndex_p,
void *pSrcData_p, void *pSrcData_p,
unsigned int uiSize_p); unsigned int uiSize_p);
tEplKernel EplApiCbObdAccess(tEplObdCbParam MEM *pParam_p); tEplKernel EplApiCbObdAccess(tEplObdCbParam *pParam_p);
tEplKernel EplApiLinkObject(unsigned int uiObjIndex_p, tEplKernel EplApiLinkObject(unsigned int uiObjIndex_p,
void *pVar_p, void *pVar_p,

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

@ -196,7 +196,7 @@ static tEplKernel EplApiCbLedStateChange(tEplLedType LedType_p, BOOL fOn_p);
#endif #endif
// OD initialization function (implemented in Objdict.c) // OD initialization function (implemented in Objdict.c)
tEplKernel EplObdInitRam(tEplObdInitParam MEM *pInitParam_p); tEplKernel EplObdInitRam(tEplObdInitParam *pInitParam_p);
//=========================================================================// //=========================================================================//
// // // //
@ -558,7 +558,7 @@ tEplKernel EplApiLinkObject(unsigned int uiObjIndex_p,
{ {
BYTE bVarEntries; BYTE bVarEntries;
BYTE bIndexEntries; BYTE bIndexEntries;
BYTE MEM *pbData; BYTE *pbData;
unsigned int uiSubindex; unsigned int uiSubindex;
tEplVarParam VarParam; tEplVarParam VarParam;
tEplObdSize EntrySize; tEplObdSize EntrySize;
@ -574,7 +574,7 @@ tEplKernel EplApiLinkObject(unsigned int uiObjIndex_p,
goto Exit; goto Exit;
} }
pbData = (BYTE MEM *) pVar_p; pbData = (BYTE *)pVar_p;
bVarEntries = (BYTE) * puiVarEntries_p; bVarEntries = (BYTE) * puiVarEntries_p;
UsedSize = 0; UsedSize = 0;
@ -962,7 +962,7 @@ tEplKernel EplApiMnTriggerStateChange(unsigned int uiNodeId_p,
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel EplApiCbObdAccess(tEplObdCbParam MEM *pParam_p) tEplKernel EplApiCbObdAccess(tEplObdCbParam *pParam_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;

34
drivers/staging/epl/EplInstDef.h
View File

@ -83,7 +83,7 @@ typedef enum {
//------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------
typedef void MEM *tEplPtrInstance; typedef void *tEplPtrInstance;
typedef BYTE tEplInstanceHdl; typedef BYTE tEplInstanceHdl;
// define const for illegale values // define const for illegale values
@ -99,7 +99,6 @@ typedef BYTE tEplInstanceHdl;
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
// memory attributes for instance table // memory attributes for instance table
#define INST_FAR // variables wich have to located in xdata
#define STATIC // prevent warnings for variables with same name #define STATIC // prevent warnings for variables with same name
#define INSTANCE_TYPE_BEGIN typedef struct { #define INSTANCE_TYPE_BEGIN typedef struct {
@ -116,12 +115,12 @@ typedef BYTE tEplInstanceHdl;
#define CCM_DECL_INSTANCE_HDL_ tEplInstanceHdl InstanceHandle, #define CCM_DECL_INSTANCE_HDL_ tEplInstanceHdl InstanceHandle,
// macros for declaration of pointer to instance handle within function header or prototype of API functions // macros for declaration of pointer to instance handle within function header or prototype of API functions
#define CCM_DECL_PTR_INSTANCE_HDL tEplInstanceHdl MEM* pInstanceHandle #define CCM_DECL_PTR_INSTANCE_HDL tEplInstanceHdl *pInstanceHandle
#define CCM_DECL_PTR_INSTANCE_HDL_ tEplInstanceHdl MEM* pInstanceHandle, #define CCM_DECL_PTR_INSTANCE_HDL_ tEplInstanceHdl *pInstanceHandle,
// macros for declaration instance as lokacl variable within functions // macros for declaration instance as lokacl variable within functions
#define CCM_DECL_INSTANCE_PTR_LOCAL tCcmInstanceInfo MEM* pInstance; #define CCM_DECL_INSTANCE_PTR_LOCAL tCcmInstanceInfo *pInstance;
#define CCM_DECL_PTR_INSTANCE_HDL_LOCAL tEplInstanceHdl MEM* pInstanceHandle; #define CCM_DECL_PTR_INSTANCE_HDL_LOCAL tEplInstanceHdl *pInstanceHandle;
// reference: // reference:
@ -162,10 +161,10 @@ typedef BYTE tEplInstanceHdl;
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
// macros for declaration within the function header, prototype or local var list // macros for declaration within the function header, prototype or local var list
// Declaration of pointers within function paramater list must defined as void MEM* // Declaration of pointers within function paramater list must defined as void *
// pointer. // pointer.
#define EPL_MCO_DECL_INSTANCE_PTR void MEM* pInstance #define EPL_MCO_DECL_INSTANCE_PTR void *pInstance
#define EPL_MCO_DECL_INSTANCE_PTR_ void MEM* pInstance, #define EPL_MCO_DECL_INSTANCE_PTR_ void *pInstance,
#define EPL_MCO_DECL_INSTANCE_PTR_LOCAL tEplPtrInstance pInstance; #define EPL_MCO_DECL_INSTANCE_PTR_LOCAL tEplPtrInstance pInstance;
// macros for reference of pointer to instance // macros for reference of pointer to instance
@ -190,8 +189,8 @@ typedef BYTE tEplInstanceHdl;
ASSERT (((tEplPtrInstance)pInstance)->m_InstState == kStateUsed); ASSERT (((tEplPtrInstance)pInstance)->m_InstState == kStateUsed);
// macros for declaration of pointer to instance pointer // macros for declaration of pointer to instance pointer
#define EPL_MCO_DECL_PTR_INSTANCE_PTR void MEM* MEM* pInstancePtr #define EPL_MCO_DECL_PTR_INSTANCE_PTR void **pInstancePtr
#define EPL_MCO_DECL_PTR_INSTANCE_PTR_ void MEM* MEM* pInstancePtr, #define EPL_MCO_DECL_PTR_INSTANCE_PTR_ void **pInstancePtr,
// macros for reference of pointer to instance pointer // macros for reference of pointer to instance pointer
// These macros are used for parameter passing to called function. // These macros are used for parameter passing to called function.
@ -211,9 +210,9 @@ typedef BYTE tEplInstanceHdl;
// this macro deletes all instance entries as unused // this macro deletes all instance entries as unused
#define EPL_MCO_DELETE_INSTANCE_TABLE() \ #define EPL_MCO_DELETE_INSTANCE_TABLE() \
{ \ { \
tEplInstanceInfo MEM* pInstance = &aEplInstanceTable_g[0]; \ tEplInstanceInfo * pInstance = &aEplInstanceTable_g[0]; \
tFastByte InstNumber = 0; \ tFastByte InstNumber = 0; \
tFastByte i = EPL_MAX_INSTANCES; \ tFastByte i = EPL_MAX_INSTANCES; \
do { \ do { \
pInstance->m_InstState = (BYTE) kStateUnused; \ pInstance->m_InstState = (BYTE) kStateUnused; \
pInstance->m_bInstIndex = (BYTE) InstNumber; \ pInstance->m_bInstIndex = (BYTE) InstNumber; \
@ -229,8 +228,8 @@ typedef BYTE tEplInstanceHdl;
static tEplPtrInstance GetInstancePtr (tEplInstanceHdl InstHandle_p) { \ static tEplPtrInstance GetInstancePtr (tEplInstanceHdl InstHandle_p) { \
return &aEplInstanceTable_g[InstHandle_p]; } \ return &aEplInstanceTable_g[InstHandle_p]; } \
static tEplPtrInstance GetFreeInstance (void) { \ static tEplPtrInstance GetFreeInstance (void) { \
tEplInstanceInfo MEM* pInstance = &aEplInstanceTable_g[0]; \ tEplInstanceInfo *pInstance = &aEplInstanceTable_g[0]; \
tFastByte i = EPL_MAX_INSTANCES; \ tFastByte i = EPL_MAX_INSTANCES; \
do { if (pInstance->m_InstState != kStateUsed) { \ do { if (pInstance->m_InstState != kStateUsed) { \
return (tEplPtrInstance) pInstance; } \ return (tEplPtrInstance) pInstance; } \
pInstance++; i--; } \ pInstance++; i--; } \
@ -239,7 +238,7 @@ typedef BYTE tEplInstanceHdl;
// this macro defines the instance table. Each entry is reserved for an instance of CANopen. // this macro defines the instance table. Each entry is reserved for an instance of CANopen.
#define EPL_MCO_DECL_INSTANCE_VAR() \ #define EPL_MCO_DECL_INSTANCE_VAR() \
static tEplInstanceInfo MEM aEplInstanceTable_g [EPL_MAX_INSTANCES]; static tEplInstanceInfo aEplInstanceTable_g [EPL_MAX_INSTANCES];
// this macro defines member variables in instance table which are needed in // this macro defines member variables in instance table which are needed in
// all modules of Epl stack // all modules of Epl stack
@ -253,7 +252,6 @@ typedef BYTE tEplInstanceHdl;
#else // only one instance is used #else // only one instance is used
// Memory attributes for instance table. // Memory attributes for instance table.
#define INST_FAR MEM // variables wich have to located in xdata
#define STATIC static // prevent warnings for variables with same name #define STATIC static // prevent warnings for variables with same name
#define INSTANCE_TYPE_BEGIN #define INSTANCE_TYPE_BEGIN

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

@ -107,12 +107,12 @@ void TgtDbgPostTraceValue(DWORD dwTraceValue_p);
// struct for instance table // struct for instance table
INSTANCE_TYPE_BEGIN EPL_MCO_DECL_INSTANCE_MEMBER() INSTANCE_TYPE_BEGIN EPL_MCO_DECL_INSTANCE_MEMBER()
STATIC volatile tEplNmtState INST_FAR m_NmtState; STATIC volatile tEplNmtState m_NmtState;
STATIC volatile BOOL INST_FAR m_fEnableReadyToOperate; STATIC volatile BOOL m_fEnableReadyToOperate;
STATIC volatile BOOL INST_FAR m_fAppReadyToOperate; STATIC volatile BOOL m_fAppReadyToOperate;
STATIC volatile BOOL INST_FAR m_fTimerMsPreOp2; STATIC volatile BOOL m_fTimerMsPreOp2;
STATIC volatile BOOL INST_FAR m_fAllMandatoryCNIdent; STATIC volatile BOOL m_fAllMandatoryCNIdent;
STATIC volatile BOOL INST_FAR m_fFrozen; STATIC volatile BOOL m_fFrozen;
INSTANCE_TYPE_END INSTANCE_TYPE_END
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -121,7 +121,7 @@ INSTANCE_TYPE_END
// This macro replace the unspecific pointer to an instance through // This macro replace the unspecific pointer to an instance through
// the modul specific type for the local instance table. This macro // the modul specific type for the local instance table. This macro
// must defined in each modul. // must defined in each modul.
//#define tEplPtrInstance tEplInstanceInfo MEM* //#define tEplPtrInstance tEplInstanceInfo*
EPL_MCO_DECL_INSTANCE_VAR() EPL_MCO_DECL_INSTANCE_VAR()
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// local function prototypes // local function prototypes

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

@ -101,7 +101,7 @@
// struct for instance table // struct for instance table
INSTANCE_TYPE_BEGIN EPL_MCO_DECL_INSTANCE_MEMBER() INSTANCE_TYPE_BEGIN EPL_MCO_DECL_INSTANCE_MEMBER()
STATIC tEplObdInitParam INST_FAR m_ObdInitParam; STATIC tEplObdInitParam m_ObdInitParam;
STATIC tEplObdStoreLoadObjCallback m_fpStoreLoadObjCallback; STATIC tEplObdStoreLoadObjCallback m_fpStoreLoadObjCallback;
INSTANCE_TYPE_END INSTANCE_TYPE_END
@ -119,11 +119,11 @@ typedef union {
// This macro replace the unspecific pointer to an instance through // This macro replace the unspecific pointer to an instance through
// the modul specific type for the local instance table. This macro // the modul specific type for the local instance table. This macro
// must defined in each modul. // must defined in each modul.
//#define tEplPtrInstance tEplInstanceInfo MEM* //#define tEplPtrInstance tEplInstanceInfo *
EPL_MCO_DECL_INSTANCE_VAR() EPL_MCO_DECL_INSTANCE_VAR()
BYTE MEM abEplObdTrashObject_g[8]; BYTE abEplObdTrashObject_g[8];
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// local function prototypes // local function prototypes
@ -133,7 +133,7 @@ EPL_MCO_DEFINE_INSTANCE_FCT()
static tEplKernel EplObdCallObjectCallback(EPL_MCO_DECL_INSTANCE_PTR_ static tEplKernel EplObdCallObjectCallback(EPL_MCO_DECL_INSTANCE_PTR_
tEplObdCallback fpCallback_p, tEplObdCallback fpCallback_p,
tEplObdCbParam MEM * pCbParam_p); tEplObdCbParam *pCbParam_p);
static tEplObdSize EplObdGetDataSizeIntern(tEplObdSubEntryPtr pSubIndexEntry_p); static tEplObdSize EplObdGetDataSizeIntern(tEplObdSubEntryPtr pSubIndexEntry_p);
@ -146,7 +146,7 @@ static tEplKernel EplObdCheckObjectRange(tEplObdSubEntryPtr pSubindexEntry_p,
#endif #endif
static tEplKernel EplObdGetVarEntry(tEplObdSubEntryPtr pSubindexEntry_p, static tEplKernel EplObdGetVarEntry(tEplObdSubEntryPtr pSubindexEntry_p,
tEplObdVarEntry MEM ** ppVarEntry_p); tEplObdVarEntry **ppVarEntry_p);
static tEplKernel EplObdGetEntry(EPL_MCO_DECL_INSTANCE_PTR_ static tEplKernel EplObdGetEntry(EPL_MCO_DECL_INSTANCE_PTR_
unsigned int uiIndex_p, unsigned int uiIndex_p,
@ -156,7 +156,7 @@ static tEplKernel EplObdGetEntry(EPL_MCO_DECL_INSTANCE_PTR_
static tEplObdSize EplObdGetObjectSize(tEplObdSubEntryPtr pSubIndexEntry_p); static tEplObdSize EplObdGetObjectSize(tEplObdSubEntryPtr pSubIndexEntry_p);
static tEplKernel EplObdGetIndexIntern(tEplObdInitParam MEM * pInitParam_p, static tEplKernel EplObdGetIndexIntern(tEplObdInitParam *pInitParam_p,
unsigned int uiIndex_p, unsigned int uiIndex_p,
tEplObdEntryPtr * ppObdEntry_p); tEplObdEntryPtr * ppObdEntry_p);
@ -170,17 +170,15 @@ static tEplKernel EplObdAccessOdPartIntern(EPL_MCO_DECL_INSTANCE_PTR_
tEplObdDir Direction_p); tEplObdDir Direction_p);
static void *EplObdGetObjectDefaultPtr(tEplObdSubEntryPtr pSubIndexEntry_p); static void *EplObdGetObjectDefaultPtr(tEplObdSubEntryPtr pSubIndexEntry_p);
static void MEM *EplObdGetObjectCurrentPtr(tEplObdSubEntryPtr pSubIndexEntry_p); static void *EplObdGetObjectCurrentPtr(tEplObdSubEntryPtr pSubIndexEntry_p);
#if (EPL_OBD_USE_STORE_RESTORE != FALSE) #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
static tEplKernel EplObdCallStoreCallback(EPL_MCO_DECL_INSTANCE_PTR_ static tEplKernel EplObdCallStoreCallback(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdCbStoreParam *pCbStoreParam_p);
tEplObdCbStoreParam MEM *
pCbStoreParam_p);
#endif // (EPL_OBD_USE_STORE_RESTORE != FALSE) #endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
static void EplObdCopyObjectData(void MEM * pDstData_p, static void EplObdCopyObjectData(void *pDstData_p,
void *pSrcData_p, void *pSrcData_p,
tEplObdSize ObjSize_p, tEplObdType ObjType_p); tEplObdSize ObjSize_p, tEplObdType ObjType_p);
@ -196,12 +194,12 @@ static tEplKernel EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int ui
tEplObdSize Size_p, tEplObdSize Size_p,
tEplObdEntryPtr *ppObdEntry_p, tEplObdEntryPtr *ppObdEntry_p,
tEplObdSubEntryPtr *ppSubEntry_p, tEplObdSubEntryPtr *ppSubEntry_p,
tEplObdCbParam MEM *pCbParam_p, tEplObdCbParam *pCbParam_p,
tEplObdSize *pObdSize_p); tEplObdSize *pObdSize_p);
static tEplKernel EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPtr pObdEntry_p, static tEplKernel EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPtr pObdEntry_p,
tEplObdSubEntryPtr pSubEntry_p, tEplObdSubEntryPtr pSubEntry_p,
tEplObdCbParam MEM *pCbParam_p, tEplObdCbParam *pCbParam_p,
void *pSrcData_p, void *pSrcData_p,
void *pDstData_p, void *pDstData_p,
tEplObdSize ObdSize_p); tEplObdSize ObdSize_p);
@ -226,7 +224,7 @@ static tEplKernel EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPt
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObdInit(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitParam MEM *pInitParam_p) EPLDLLEXPORT tEplKernel EplObdInit(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitParam *pInitParam_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -258,7 +256,7 @@ EPLDLLEXPORT tEplKernel EplObdInit(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitPar
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObdAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitParam MEM *pInitParam_p) EPLDLLEXPORT tEplKernel EplObdAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitParam *pInitParam_p)
{ {
EPL_MCO_DECL_INSTANCE_PTR_LOCAL tEplKernel Ret; EPL_MCO_DECL_INSTANCE_PTR_LOCAL tEplKernel Ret;
@ -345,8 +343,8 @@ EPLDLLEXPORT tEplKernel EplObdWriteEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int
tEplKernel Ret; tEplKernel Ret;
tEplObdEntryPtr pObdEntry; tEplObdEntryPtr pObdEntry;
tEplObdSubEntryPtr pSubEntry; tEplObdSubEntryPtr pSubEntry;
tEplObdCbParam MEM CbParam; tEplObdCbParam CbParam;
void MEM *pDstData; void *pDstData;
tEplObdSize ObdSize; tEplObdSize ObdSize;
Ret = EplObdWriteEntryPre(EPL_MCO_INSTANCE_PTR_ Ret = EplObdWriteEntryPre(EPL_MCO_INSTANCE_PTR_
@ -405,7 +403,7 @@ EPLDLLEXPORT tEplKernel EplObdReadEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int
tEplKernel Ret; tEplKernel Ret;
tEplObdEntryPtr pObdEntry; tEplObdEntryPtr pObdEntry;
tEplObdSubEntryPtr pSubEntry; tEplObdSubEntryPtr pSubEntry;
tEplObdCbParam MEM CbParam; tEplObdCbParam CbParam;
void *pSrcData; void *pSrcData;
tEplObdSize ObdSize; tEplObdSize ObdSize;
@ -579,11 +577,11 @@ EPLDLLEXPORT tEplKernel EplObdAccessOdPart(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdPar
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObdDefineVar(EPL_MCO_DECL_INSTANCE_PTR_ tEplVarParam MEM *pVarParam_p) EPLDLLEXPORT tEplKernel EplObdDefineVar(EPL_MCO_DECL_INSTANCE_PTR_ tEplVarParam *pVarParam_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplObdVarEntry MEM *pVarEntry; tEplObdVarEntry *pVarEntry;
tEplVarParamValid VarValid; tEplVarParamValid VarValid;
tEplObdSubEntryPtr pSubindexEntry; tEplObdSubEntryPtr pSubindexEntry;
@ -738,7 +736,7 @@ EPLDLLEXPORT tEplKernel EplObdRegisterUserOd(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdE
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT void EplObdInitVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdVarEntry MEM *pVarEntry_p, EPLDLLEXPORT void EplObdInitVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdVarEntry *pVarEntry_p,
tEplObdType Type_p, tEplObdSize ObdSize_p) tEplObdType Type_p, tEplObdSize ObdSize_p)
{ {
/* /*
@ -1010,7 +1008,7 @@ EPLDLLEXPORT tEplKernel EplObdReadEntryToLe(EPL_MCO_DECL_INSTANCE_PTR_ unsigned
tEplKernel Ret; tEplKernel Ret;
tEplObdEntryPtr pObdEntry; tEplObdEntryPtr pObdEntry;
tEplObdSubEntryPtr pSubEntry; tEplObdSubEntryPtr pSubEntry;
tEplObdCbParam MEM CbParam; tEplObdCbParam CbParam;
void *pSrcData; void *pSrcData;
tEplObdSize ObdSize; tEplObdSize ObdSize;
@ -1190,8 +1188,8 @@ EPLDLLEXPORT tEplKernel EplObdWriteEntryFromLe(EPL_MCO_DECL_INSTANCE_PTR_ unsign
tEplKernel Ret; tEplKernel Ret;
tEplObdEntryPtr pObdEntry; tEplObdEntryPtr pObdEntry;
tEplObdSubEntryPtr pSubEntry; tEplObdSubEntryPtr pSubEntry;
tEplObdCbParam MEM CbParam; tEplObdCbParam CbParam;
void MEM *pDstData; void *pDstData;
tEplObdSize ObdSize; tEplObdSize ObdSize;
QWORD qwBuffer; QWORD qwBuffer;
void *pBuffer = &qwBuffer; void *pBuffer = &qwBuffer;
@ -1371,7 +1369,7 @@ EPLDLLEXPORT tEplKernel EplObdGetAccessType(EPL_MCO_DECL_INSTANCE_PTR_ unsigned
tEplKernel EplObdSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p, tEplKernel EplObdSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiSubindex_p, unsigned int uiSubindex_p,
tEplObdVarEntry MEM **ppVarEntry_p) tEplObdVarEntry **ppVarEntry_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -1415,11 +1413,11 @@ EPL_MCO_DECL_INSTANCE_FCT()
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel EplObdCallObjectCallback(EPL_MCO_DECL_INSTANCE_PTR_ static tEplKernel EplObdCallObjectCallback(EPL_MCO_DECL_INSTANCE_PTR_
tEplObdCallback fpCallback_p, tEplObdCallback fpCallback_p,
tEplObdCbParam MEM * pCbParam_p) tEplObdCbParam *pCbParam_p)
{ {
tEplKernel Ret; tEplKernel Ret;
tEplObdCallback MEM fpCallback; tEplObdCallback fpCallback;
// 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();
@ -1461,7 +1459,7 @@ static tEplObdSize EplObdGetDataSizeIntern(tEplObdSubEntryPtr pSubIndexEntry_p)
{ {
tEplObdSize DataSize; tEplObdSize DataSize;
void MEM *pData; void *pData;
// If OD entry is defined by macro EPL_OBD_SUBINDEX_ROM_VSTRING // If OD entry is defined by macro EPL_OBD_SUBINDEX_ROM_VSTRING
// then the current pointer is always NULL. The function // then the current pointer is always NULL. The function
@ -1470,8 +1468,7 @@ static tEplObdSize EplObdGetDataSizeIntern(tEplObdSubEntryPtr pSubIndexEntry_p)
if (pSubIndexEntry_p->m_Type == kEplObdTypVString) { if (pSubIndexEntry_p->m_Type == kEplObdTypVString) {
// The pointer to current value can be received from EplObdGetObjectCurrentPtr() // The pointer to current value can be received from EplObdGetObjectCurrentPtr()
pData = pData = ((void *)EplObdGetObjectCurrentPtr(pSubIndexEntry_p));
((void MEM *)EplObdGetObjectCurrentPtr(pSubIndexEntry_p));
if (pData != NULL) { if (pData != NULL) {
DataSize = DataSize =
EplObdGetStrLen((void *)pData, DataSize, EplObdGetStrLen((void *)pData, DataSize,
@ -1857,7 +1854,7 @@ static tEplKernel EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int ui
tEplObdSize Size_p, tEplObdSize Size_p,
tEplObdEntryPtr *ppObdEntry_p, tEplObdEntryPtr *ppObdEntry_p,
tEplObdSubEntryPtr *ppSubEntry_p, tEplObdSubEntryPtr *ppSubEntry_p,
tEplObdCbParam MEM *pCbParam_p, tEplObdCbParam *pCbParam_p,
tEplObdSize *pObdSize_p) tEplObdSize *pObdSize_p)
{ {
@ -1865,13 +1862,13 @@ static tEplKernel EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int ui
tEplObdEntryPtr pObdEntry; tEplObdEntryPtr pObdEntry;
tEplObdSubEntryPtr pSubEntry; tEplObdSubEntryPtr pSubEntry;
tEplObdAccess Access; tEplObdAccess Access;
void MEM *pDstData; void *pDstData;
tEplObdSize ObdSize; tEplObdSize ObdSize;
BOOL fEntryNumerical; BOOL fEntryNumerical;
#if (EPL_OBD_USE_STRING_DOMAIN_IN_RAM != FALSE) #if (EPL_OBD_USE_STRING_DOMAIN_IN_RAM != FALSE)
tEplObdVStringDomain MEM MemVStringDomain; tEplObdVStringDomain MemVStringDomain;
void MEM *pCurrData; void *pCurrData;
#endif #endif
// check for all API function if instance is valid // check for all API function if instance is valid
@ -1887,7 +1884,7 @@ static tEplKernel EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int ui
goto Exit; goto Exit;
} }
// get pointer to object data // get pointer to object data
pDstData = (void MEM *)EplObdGetObjectDataPtrIntern(pSubEntry); pDstData = (void *)EplObdGetObjectDataPtrIntern(pSubEntry);
Access = (tEplObdAccess) pSubEntry->m_Access; Access = (tEplObdAccess) pSubEntry->m_Access;
@ -1912,7 +1909,7 @@ static tEplKernel EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int ui
// adapted by user callback function, re-read // adapted by user callback function, re-read
// this values. // this values.
ObdSize = EplObdGetObjectSize(pSubEntry); ObdSize = EplObdGetObjectSize(pSubEntry);
pDstData = (void MEM *)EplObdGetObjectDataPtrIntern(pSubEntry); pDstData = (void *)EplObdGetObjectDataPtrIntern(pSubEntry);
// 09-dec-2004 r.d.: // 09-dec-2004 r.d.:
// Function EplObdWriteEntry() calls new event kEplObdEvWrStringDomain // Function EplObdWriteEntry() calls new event kEplObdEvWrStringDomain
@ -1946,23 +1943,19 @@ static tEplKernel EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int ui
pCurrData = pSubEntry->m_pCurrent; pCurrData = pSubEntry->m_pCurrent;
if ((pSubEntry->m_Type == kEplObdTypVString) if ((pSubEntry->m_Type == kEplObdTypVString)
|| (pSubEntry->m_Type == kEplObdTypOString)) { || (pSubEntry->m_Type == kEplObdTypOString)) {
((tEplObdVString MEM *) pCurrData)->m_Size = ((tEplObdVString *)pCurrData)->m_Size = MemVStringDomain.m_ObjSize;
MemVStringDomain.m_ObjSize; ((tEplObdVString *)pCurrData)->m_pString = MemVStringDomain.m_pData;
((tEplObdVString MEM *) pCurrData)->m_pString =
MemVStringDomain.m_pData;
} else // if (pSdosTableEntry_p->m_bObjType == kEplObdTypDomain) } else // if (pSdosTableEntry_p->m_bObjType == kEplObdTypDomain)
{ {
((tEplObdVarEntry MEM *) pCurrData)->m_Size = ((tEplObdVarEntry *)pCurrData)->m_Size = MemVStringDomain.m_ObjSize;
MemVStringDomain.m_ObjSize; ((tEplObdVarEntry *)pCurrData)->m_pData = (void *)MemVStringDomain.m_pData;
((tEplObdVarEntry MEM *) pCurrData)->m_pData =
(void MEM *)MemVStringDomain.m_pData;
} }
// Because object size and object pointer are // Because object size and object pointer are
// adapted by user callback function, re-read // adapted by user callback function, re-read
// this values. // this values.
ObdSize = MemVStringDomain.m_ObjSize; ObdSize = MemVStringDomain.m_ObjSize;
pDstData = (void MEM *)MemVStringDomain.m_pData; pDstData = (void *)MemVStringDomain.m_pData;
} }
#endif //#if (OBD_USE_STRING_DOMAIN_IN_RAM != FALSE) #endif //#if (OBD_USE_STRING_DOMAIN_IN_RAM != FALSE)
@ -1983,7 +1976,7 @@ static tEplKernel EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int ui
} }
if (pSubEntry->m_Type == kEplObdTypVString) { if (pSubEntry->m_Type == kEplObdTypVString) {
if (((char MEM *)pSrcData_p)[Size_p - 1] == '\0') { // last byte of source string contains null character if (((char *)pSrcData_p)[Size_p - 1] == '\0') { // last byte of source string contains null character
// reserve one byte in destination for 0-termination // reserve one byte in destination for 0-termination
Size_p -= 1; Size_p -= 1;
@ -2045,7 +2038,7 @@ static tEplKernel EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int ui
static tEplKernel EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPtr pObdEntry_p, static tEplKernel EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPtr pObdEntry_p,
tEplObdSubEntryPtr pSubEntry_p, tEplObdSubEntryPtr pSubEntry_p,
tEplObdCbParam MEM *pCbParam_p, tEplObdCbParam *pCbParam_p,
void *pSrcData_p, void *pSrcData_p,
void *pDstData_p, void *pDstData_p,
tEplObdSize ObdSize_p) tEplObdSize ObdSize_p)
@ -2081,7 +2074,7 @@ static tEplKernel EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPt
// terminate string with 0 // terminate string with 0
if (pSubEntry_p->m_Type == kEplObdTypVString) { if (pSubEntry_p->m_Type == kEplObdTypVString) {
((char MEM *)pDstData_p)[ObdSize_p] = '\0'; ((char *)pDstData_p)[ObdSize_p] = '\0';
} }
// write address of destination to structure of callback parameters // write address of destination to structure of callback parameters
// so callback function can change data subsequently // so callback function can change data subsequently
@ -2170,8 +2163,8 @@ static tEplObdSize EplObdGetObjectSize(tEplObdSubEntryPtr pSubIndexEntry_p)
case kEplObdTypDomain: case kEplObdTypDomain:
pData = (void *)pSubIndexEntry_p->m_pCurrent; pData = (void *)pSubIndexEntry_p->m_pCurrent;
if ((void MEM *)pData != (void MEM *)NULL) { if ((void *)pData != (void *)NULL) {
DataSize = ((tEplObdVarEntry MEM *) pData)->m_Size; DataSize = ((tEplObdVarEntry *) pData)->m_Size;
} }
break; break;
@ -2183,11 +2176,11 @@ static tEplObdSize EplObdGetObjectSize(tEplObdSubEntryPtr pSubIndexEntry_p)
// then the current pointer is always NULL. The function // then the current pointer is always NULL. The function
// returns the length of default string. // returns the length of default string.
pData = (void *)pSubIndexEntry_p->m_pCurrent; pData = (void *)pSubIndexEntry_p->m_pCurrent;
if ((void MEM *)pData != (void MEM *)NULL) { if ((void *)pData != (void *)NULL) {
// The max. size of strings defined by STRING-Macro is stored in // The max. size of strings defined by STRING-Macro is stored in
// tEplObdVString of current value. // tEplObdVString of current value.
// (types tEplObdVString, tEplObdOString and tEplObdUString has the same members) // (types tEplObdVString, tEplObdOString and tEplObdUString has the same members)
DataSize = ((tEplObdVString MEM *) pData)->m_Size; DataSize = ((tEplObdVString *) pData)->m_Size;
} else { } else {
// The current position is not decleared. The string // The current position is not decleared. The string
// is located in ROM, therefor use default pointer. // is located in ROM, therefor use default pointer.
@ -2207,11 +2200,11 @@ static tEplObdSize EplObdGetObjectSize(tEplObdSubEntryPtr pSubIndexEntry_p)
case kEplObdTypOString: case kEplObdTypOString:
pData = (void *)pSubIndexEntry_p->m_pCurrent; pData = (void *)pSubIndexEntry_p->m_pCurrent;
if ((void MEM *)pData != (void MEM *)NULL) { if ((void *)pData != (void *)NULL) {
// The max. size of strings defined by STRING-Macro is stored in // The max. size of strings defined by STRING-Macro is stored in
// tEplObdVString of current value. // tEplObdVString of current value.
// (types tEplObdVString, tEplObdOString and tEplObdUString has the same members) // (types tEplObdVString, tEplObdOString and tEplObdUString has the same members)
DataSize = ((tEplObdOString MEM *) pData)->m_Size; DataSize = ((tEplObdOString *) pData)->m_Size;
} else { } else {
// The current position is not decleared. The string // The current position is not decleared. The string
// is located in ROM, therefor use default pointer. // is located in ROM, therefor use default pointer.
@ -2344,7 +2337,7 @@ static void *EplObdGetObjectDefaultPtr(tEplObdSubEntryPtr pSubIndexEntry_p)
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel EplObdGetVarEntry(tEplObdSubEntryPtr pSubindexEntry_p, static tEplKernel EplObdGetVarEntry(tEplObdSubEntryPtr pSubindexEntry_p,
tEplObdVarEntry MEM ** ppVarEntry_p) tEplObdVarEntry **ppVarEntry_p)
{ {
tEplKernel Ret = kEplObdVarEntryNotExist; tEplKernel Ret = kEplObdVarEntryNotExist;
@ -2356,13 +2349,9 @@ static tEplKernel EplObdGetVarEntry(tEplObdSubEntryPtr pSubindexEntry_p,
if ((pSubindexEntry_p->m_Access & kEplObdAccVar) != 0) { if ((pSubindexEntry_p->m_Access & kEplObdAccVar) != 0) {
// check if object is an array // check if object is an array
if ((pSubindexEntry_p->m_Access & kEplObdAccArray) != 0) { if ((pSubindexEntry_p->m_Access & kEplObdAccArray) != 0) {
*ppVarEntry_p = *ppVarEntry_p = &((tEplObdVarEntry *)pSubindexEntry_p->m_pCurrent)[pSubindexEntry_p->m_uiSubIndex - 1];
&((tEplObdVarEntry MEM *) pSubindexEntry_p->
m_pCurrent)[pSubindexEntry_p->m_uiSubIndex - 1];
} else { } else {
*ppVarEntry_p = *ppVarEntry_p = (tEplObdVarEntry *)pSubindexEntry_p->m_pCurrent;
(tEplObdVarEntry MEM *) pSubindexEntry_p->
m_pCurrent;
} }
Ret = kEplSuccessful; Ret = kEplSuccessful;
@ -2398,7 +2387,7 @@ static tEplKernel EplObdGetEntry(EPL_MCO_DECL_INSTANCE_PTR_
{ {
tEplObdEntryPtr pObdEntry; tEplObdEntryPtr pObdEntry;
tEplObdCbParam MEM CbParam; tEplObdCbParam CbParam;
tEplKernel Ret; tEplKernel Ret;
// check for all API function if instance is valid // check for all API function if instance is valid
@ -2452,16 +2441,16 @@ static tEplKernel EplObdGetEntry(EPL_MCO_DECL_INSTANCE_PTR_
// //
// Parameters: pSubIndexEntry_p // Parameters: pSubIndexEntry_p
// //
// Return: void MEM* // Return: void *
// //
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static void MEM *EplObdGetObjectCurrentPtr(tEplObdSubEntryPtr pSubIndexEntry_p) static void *EplObdGetObjectCurrentPtr(tEplObdSubEntryPtr pSubIndexEntry_p)
{ {
void MEM *pData; void *pData;
unsigned int uiArrayIndex; unsigned int uiArrayIndex;
tEplObdSize Size; tEplObdSize Size;
@ -2478,24 +2467,21 @@ static void MEM *EplObdGetObjectCurrentPtr(tEplObdSubEntryPtr pSubIndexEntry_p)
} else { } else {
Size = EplObdGetObjectSize(pSubIndexEntry_p); Size = EplObdGetObjectSize(pSubIndexEntry_p);
} }
pData = ((BYTE MEM *) pData) + (Size * uiArrayIndex); pData = ((BYTE *) pData) + (Size * uiArrayIndex);
} }
// check if VarEntry // check if VarEntry
if ((pSubIndexEntry_p->m_Access & kEplObdAccVar) != 0) { if ((pSubIndexEntry_p->m_Access & kEplObdAccVar) != 0) {
// The data pointer is stored in VarEntry->pData // The data pointer is stored in VarEntry->pData
pData = ((tEplObdVarEntry MEM *) pData)->m_pData; pData = ((tEplObdVarEntry *) pData)->m_pData;
} }
// the default pointer is stored for strings in tEplObdVString // the default pointer is stored for strings in tEplObdVString
else if ((pSubIndexEntry_p->m_Type == kEplObdTypVString) /* || else if ((pSubIndexEntry_p->m_Type == kEplObdTypVString) /* ||
(pSubIndexEntry_p->m_Type == kEplObdTypUString) */ (pSubIndexEntry_p->m_Type == kEplObdTypUString) */
) { ) {
pData = pData = (void *)((tEplObdVString *)pData)->m_pString;
(void MEM *)((tEplObdVString MEM *) pData)->
m_pString;
} else if (pSubIndexEntry_p->m_Type == kEplObdTypOString) { } else if (pSubIndexEntry_p->m_Type == kEplObdTypOString) {
pData = pData =
(void MEM *)((tEplObdOString MEM *) pData)-> (void *)((tEplObdOString *)pData)->m_pString;
m_pString;
} }
} }
@ -2519,7 +2505,7 @@ static void MEM *EplObdGetObjectCurrentPtr(tEplObdSubEntryPtr pSubIndexEntry_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel EplObdGetIndexIntern(tEplObdInitParam MEM * pInitParam_p, static tEplKernel EplObdGetIndexIntern(tEplObdInitParam *pInitParam_p,
unsigned int uiIndex_p, unsigned int uiIndex_p,
tEplObdEntryPtr * ppObdEntry_p) tEplObdEntryPtr * ppObdEntry_p)
{ {
@ -2778,12 +2764,12 @@ static tEplKernel EplObdAccessOdPartIntern(EPL_MCO_DECL_INSTANCE_PTR_
tEplObdSubEntryPtr pSubIndex; tEplObdSubEntryPtr pSubIndex;
unsigned int nSubIndexCount; unsigned int nSubIndexCount;
tEplObdAccess Access; tEplObdAccess Access;
void MEM *pDstData; void *pDstData;
void *pDefault; void *pDefault;
tEplObdSize ObjSize; tEplObdSize ObjSize;
tEplKernel Ret; tEplKernel Ret;
tEplObdCbStoreParam MEM CbStore; tEplObdCbStoreParam CbStore;
tEplObdVarEntry MEM *pVarEntry; tEplObdVarEntry *pVarEntry;
ASSERT(pObdEnty_p != NULL); ASSERT(pObdEnty_p != NULL);
@ -2866,7 +2852,7 @@ static tEplKernel EplObdAccessOdPartIntern(EPL_MCO_DECL_INSTANCE_PTR_
} }
else else
{ {
EplObdInitVarEntry ((tEplObdVarEntry MEM*) (((BYTE MEM*) pSubIndex->m_pCurrent) + (sizeof (tEplObdVarEntry) * pSubIndex->m_uiSubIndex)), EplObdInitVarEntry ((tEplObdVarEntry *) (((BYTE *) pSubIndex->m_pCurrent) + (sizeof (tEplObdVarEntry) * pSubIndex->m_uiSubIndex)),
pSubIndex->m_Type, ObjSize); pSubIndex->m_Type, ObjSize);
} }
*/ */
@ -2893,11 +2879,11 @@ static tEplKernel EplObdAccessOdPartIntern(EPL_MCO_DECL_INSTANCE_PTR_
// For copying data we have to set the destination pointer to the real RAM string. This // For copying data we have to set the destination pointer to the real RAM string. This
// pointer to RAM string is located in default string info structure. (translated r.d.) // pointer to RAM string is located in default string info structure. (translated r.d.)
pDstData = (void MEM *)((tEplObdVStringDef*) pSubIndex->m_pDefault)->m_pString; pDstData = (void *)((tEplObdVStringDef*) pSubIndex->m_pDefault)->m_pString;
ObjSize = ((tEplObdVStringDef *)pSubIndex->m_pDefault)->m_Size; ObjSize = ((tEplObdVStringDef *)pSubIndex->m_pDefault)->m_Size;
((tEplObdVString MEM *)pSubIndex->m_pCurrent)->m_pString = pDstData; ((tEplObdVString *)pSubIndex->m_pCurrent)->m_pString = pDstData;
((tEplObdVString MEM *)pSubIndex->m_pCurrent)->m_Size = ObjSize; ((tEplObdVString *)pSubIndex->m_pCurrent)->m_Size = ObjSize;
} }
} else if (pSubIndex->m_Type == } else if (pSubIndex->m_Type ==
@ -2912,11 +2898,11 @@ static tEplKernel EplObdAccessOdPartIntern(EPL_MCO_DECL_INSTANCE_PTR_
// For copying data we have to set the destination pointer to the real RAM string. This // For copying data we have to set the destination pointer to the real RAM string. This
// pointer to RAM string is located in default string info structure. (translated r.d.) // pointer to RAM string is located in default string info structure. (translated r.d.)
pDstData = (void MEM *)((tEplObdOStringDef *) pSubIndex->m_pDefault)->m_pString; pDstData = (void *)((tEplObdOStringDef *) pSubIndex->m_pDefault)->m_pString;
ObjSize = ((tEplObdOStringDef *)pSubIndex->m_pDefault)->m_Size; ObjSize = ((tEplObdOStringDef *)pSubIndex->m_pDefault)->m_Size;
((tEplObdOString MEM *)pSubIndex->m_pCurrent)->m_pString = pDstData; ((tEplObdOString *)pSubIndex->m_pCurrent)->m_pString = pDstData;
((tEplObdOString MEM *)pSubIndex->m_pCurrent)->m_Size = ObjSize; ((tEplObdOString *)pSubIndex->m_pCurrent)->m_Size = ObjSize;
} }
} }
@ -3056,7 +3042,7 @@ static tEplKernel EplObdAccessOdPartIntern(EPL_MCO_DECL_INSTANCE_PTR_
// Returns: tEplKernel = error code // Returns: tEplKernel = error code
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
static void EplObdCopyObjectData(void MEM * pDstData_p, static void EplObdCopyObjectData(void *pDstData_p,
void *pSrcData_p, void *pSrcData_p,
tEplObdSize ObjSize_p, tEplObdType ObjType_p) tEplObdSize ObjSize_p, tEplObdType ObjType_p)
{ {
@ -3087,7 +3073,7 @@ static void EplObdCopyObjectData(void MEM * pDstData_p,
EPL_MEMCPY(pDstData_p, pSrcData_p, ObjSize_p); EPL_MEMCPY(pDstData_p, pSrcData_p, ObjSize_p);
if (ObjType_p == kEplObdTypVString) { if (ObjType_p == kEplObdTypVString) {
((char MEM *)pDstData_p)[StrSize] = '\0'; ((char *)pDstData_p)[StrSize] = '\0';
} }
} }
} }
@ -3148,7 +3134,7 @@ static tEplKernel EplObdIsNumericalIntern(tEplObdSubEntryPtr pObdSubEntry_p,
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
#if (EPL_OBD_USE_STORE_RESTORE != FALSE) #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
static tEplKernel EplObdCallStoreCallback(EPL_MCO_DECL_INSTANCE_PTR_ static tEplKernel EplObdCallStoreCallback(EPL_MCO_DECL_INSTANCE_PTR_
tEplObdCbStoreParam MEM * tEplObdCbStoreParam *
pCbStoreParam_p) pCbStoreParam_p)
{ {

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

@ -290,14 +290,14 @@ typedef struct {
unsigned int m_uiIndex; unsigned int m_uiIndex;
unsigned int m_uiSubindex; unsigned int m_uiSubindex;
tEplObdSize m_Size; tEplObdSize m_Size;
void MEM *m_pData; void *m_pData;
// tEplVarCallback m_fpCallback; // tEplVarCallback m_fpCallback;
// void * m_pArg; // void * m_pArg;
} tEplVarParam; } tEplVarParam;
typedef struct { typedef struct {
void MEM *m_pData; void *m_pData;
tEplObdSize m_Size; tEplObdSize m_Size;
/* /*
#if (EPL_PDO_USE_STATIC_MAPPING == FALSE) #if (EPL_PDO_USE_STATIC_MAPPING == FALSE)
@ -353,7 +353,7 @@ typedef struct {
tEplObdType m_Type; tEplObdType m_Type;
tEplObdAccess m_Access; tEplObdAccess m_Access;
void *m_pDefault; void *m_pDefault;
void MEM *m_pCurrent; // points always to RAM void *m_pCurrent; // points always to RAM
} tEplObdSubEntry; } tEplObdSubEntry;
@ -375,7 +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(*tEplObdCallback) (CCM_DECL_INSTANCE_HDL_ tEplObdCbParam MEM * pParam_p); typedef tEplKernel(*tEplObdCallback) (CCM_DECL_INSTANCE_HDL_ tEplObdCbParam *pParam_p);
// do not change the order for this struct!!! // do not change the order for this struct!!!
@ -414,15 +414,14 @@ typedef struct {
typedef struct { typedef struct {
tEplObdCommand m_bCommand; tEplObdCommand m_bCommand;
tEplObdPart m_bCurrentOdPart; tEplObdPart m_bCurrentOdPart;
void MEM *m_pData; void *m_pData;
tEplObdSize m_ObjSize; tEplObdSize m_ObjSize;
} tEplObdCbStoreParam; } tEplObdCbStoreParam;
typedef tEplKernel(*tInitTabEntryCallback) (void MEM * pTabEntry_p, typedef tEplKernel(*tInitTabEntryCallback) (void *pTabEntry_p, unsigned int uiObjIndex_p);
unsigned int uiObjIndex_p);
typedef tEplKernel(*tEplObdStoreLoadObjCallback) (CCM_DECL_INSTANCE_HDL_ tEplObdCbStoreParam MEM *pCbStoreParam_p); typedef tEplKernel(*tEplObdStoreLoadObjCallback) (CCM_DECL_INSTANCE_HDL_ tEplObdCbStoreParam *pCbStoreParam_p);
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
// this stucture is used for parameters for function ObdInitModuleTab() // this stucture is used for parameters for function ObdInitModuleTab()
@ -431,7 +430,7 @@ typedef struct {
unsigned int m_uiLowerObjIndex; // lower limit of ObjIndex unsigned int m_uiLowerObjIndex; // lower limit of ObjIndex
unsigned int m_uiUpperObjIndex; // upper limit of ObjIndex unsigned int m_uiUpperObjIndex; // upper limit of ObjIndex
tInitTabEntryCallback m_fpInitTabEntry; // will be called if ObjIndex was found tInitTabEntryCallback m_fpInitTabEntry; // will be called if ObjIndex was found
void MEM *m_pTabBase; // base address of table void *m_pTabBase; // base address of table
unsigned int m_uiEntrySize; // size of table entry // 25-feb-2005 r.d.: expansion from BYTE to WORD necessary for PDO bit mapping unsigned int m_uiEntrySize; // size of table entry // 25-feb-2005 r.d.: expansion from BYTE to WORD necessary for PDO bit mapping
unsigned int m_uiMaxEntries; // max. tabel entries unsigned int m_uiMaxEntries; // max. tabel entries

36
drivers/staging/epl/EplObdMacro.h
View File

@ -102,10 +102,10 @@
#define EPL_OBD_SUBINDEX_RAM_VAR(ind,sub,typ,acc,dtyp,name,val) static dtyp xDef##ind##_##sub##_g = val; #define EPL_OBD_SUBINDEX_RAM_VAR(ind,sub,typ,acc,dtyp,name,val) static dtyp xDef##ind##_##sub##_g = val;
#define EPL_OBD_SUBINDEX_RAM_VAR_RG(ind,sub,typ,acc,dtyp,name,val,low,high) static dtyp xDef##ind##_##sub##_g[3] = {val,low,high}; #define EPL_OBD_SUBINDEX_RAM_VAR_RG(ind,sub,typ,acc,dtyp,name,val,low,high) static dtyp xDef##ind##_##sub##_g[3] = {val,low,high};
#define EPL_OBD_SUBINDEX_RAM_VAR_NOINIT(ind,sub,typ,acc,dtyp,name) #define EPL_OBD_SUBINDEX_RAM_VAR_NOINIT(ind,sub,typ,acc,dtyp,name)
#define EPL_OBD_SUBINDEX_RAM_VSTRING(ind,sub,acc,name,size,val) static char MEM szCur##ind##_##sub##_g[size+1]; \ #define EPL_OBD_SUBINDEX_RAM_VSTRING(ind,sub,acc,name,size,val) static char szCur##ind##_##sub##_g[size+1]; \
static tEplObdVStringDef xDef##ind##_##sub##_g = {size, val, szCur##ind##_##sub##_g}; static tEplObdVStringDef xDef##ind##_##sub##_g = {size, val, szCur##ind##_##sub##_g};
#define EPL_OBD_SUBINDEX_RAM_OSTRING(ind,sub,acc,name,size) static BYTE MEM bCur##ind##_##sub##_g[size]; \ #define EPL_OBD_SUBINDEX_RAM_OSTRING(ind,sub,acc,name,size) static BYTE bCur##ind##_##sub##_g[size]; \
static tEplObdOStringDef xDef##ind##_##sub##_g = {size, ((BYTE*)""), bCur##ind##_##sub##_g}; static tEplObdOStringDef xDef##ind##_##sub##_g = {size, ((BYTE*)""), bCur##ind##_##sub##_g};
#define EPL_OBD_SUBINDEX_RAM_DOMAIN(ind,sub,acc,name) #define EPL_OBD_SUBINDEX_RAM_DOMAIN(ind,sub,acc,name)
#define EPL_OBD_SUBINDEX_RAM_USERDEF(ind,sub,typ,acc,dtyp,name,val) static dtyp xDef##ind##_##sub##_g = val; #define EPL_OBD_SUBINDEX_RAM_USERDEF(ind,sub,typ,acc,dtyp,name,val) static dtyp xDef##ind##_##sub##_g = val;
@ -129,20 +129,20 @@
//--------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------
#define EPL_OBD_BEGIN_INDEX_RAM(ind,cnt,call) #define EPL_OBD_BEGIN_INDEX_RAM(ind,cnt,call)
#define EPL_OBD_END_INDEX(ind) #define EPL_OBD_END_INDEX(ind)
#define EPL_OBD_RAM_INDEX_RAM_ARRAY(ind,cnt,call,typ,acc,dtyp,name,def) static dtyp MEM axCur##ind##_g[cnt]; #define EPL_OBD_RAM_INDEX_RAM_ARRAY(ind,cnt,call,typ,acc,dtyp,name,def) static dtyp axCur##ind##_g[cnt];
#define EPL_OBD_RAM_INDEX_RAM_VARARRAY(ind,cnt,call,typ,acc,dtyp,name,def) static tEplObdVarEntry MEM aVarEntry##ind##_g[cnt]; #define EPL_OBD_RAM_INDEX_RAM_VARARRAY(ind,cnt,call,typ,acc,dtyp,name,def) static tEplObdVarEntry aVarEntry##ind##_g[cnt];
#define EPL_OBD_RAM_INDEX_RAM_VARARRAY_NOINIT(ind,cnt,call,typ,acc,dtyp,name) static tEplObdVarEntry MEM aVarEntry##ind##_g[cnt]; #define EPL_OBD_RAM_INDEX_RAM_VARARRAY_NOINIT(ind,cnt,call,typ,acc,dtyp,name) static tEplObdVarEntry aVarEntry##ind##_g[cnt];
//--------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------
#define EPL_OBD_SUBINDEX_RAM_VAR(ind,sub,typ,acc,dtyp,name,val) static dtyp MEM xCur##ind##_##sub##_g; #define EPL_OBD_SUBINDEX_RAM_VAR(ind,sub,typ,acc,dtyp,name,val) static dtyp xCur##ind##_##sub##_g;
#define EPL_OBD_SUBINDEX_RAM_VAR_RG(ind,sub,typ,acc,dtyp,name,val,low,high) static dtyp MEM xCur##ind##_##sub##_g; #define EPL_OBD_SUBINDEX_RAM_VAR_RG(ind,sub,typ,acc,dtyp,name,val,low,high) static dtyp xCur##ind##_##sub##_g;
#define EPL_OBD_SUBINDEX_RAM_VSTRING(ind,sub,acc,name,size,val) static tEplObdVString MEM xCur##ind##_##sub##_g; #define EPL_OBD_SUBINDEX_RAM_VSTRING(ind,sub,acc,name,size,val) static tEplObdVString xCur##ind##_##sub##_g;
#define EPL_OBD_SUBINDEX_RAM_OSTRING(ind,sub,acc,name,size) static tEplObdOString MEM xCur##ind##_##sub##_g; #define EPL_OBD_SUBINDEX_RAM_OSTRING(ind,sub,acc,name,size) static tEplObdOString xCur##ind##_##sub##_g;
#define EPL_OBD_SUBINDEX_RAM_VAR_NOINIT(ind,sub,typ,acc,dtyp,name) static dtyp MEM xCur##ind##_##sub##_g; #define EPL_OBD_SUBINDEX_RAM_VAR_NOINIT(ind,sub,typ,acc,dtyp,name) static dtyp xCur##ind##_##sub##_g;
#define EPL_OBD_SUBINDEX_RAM_DOMAIN(ind,sub,acc,name) static tEplObdVarEntry MEM VarEntry##ind##_##sub##_g; #define EPL_OBD_SUBINDEX_RAM_DOMAIN(ind,sub,acc,name) static tEplObdVarEntry VarEntry##ind##_##sub##_g;
#define EPL_OBD_SUBINDEX_RAM_USERDEF(ind,sub,typ,acc,dtyp,name,val) static tEplObdVarEntry MEM VarEntry##ind##_##sub##_g; #define EPL_OBD_SUBINDEX_RAM_USERDEF(ind,sub,typ,acc,dtyp,name,val) static tEplObdVarEntry VarEntry##ind##_##sub##_g;
#define EPL_OBD_SUBINDEX_RAM_USERDEF_RG(ind,sub,typ,acc,dtyp,name,val,low,high) static tEplObdVarEntry MEM VarEntry##ind##_##sub##_g; #define EPL_OBD_SUBINDEX_RAM_USERDEF_RG(ind,sub,typ,acc,dtyp,name,val,low,high) static tEplObdVarEntry VarEntry##ind##_##sub##_g;
#define EPL_OBD_SUBINDEX_RAM_USERDEF_NOINIT(ind,sub,typ,acc,dtyp,name) static tEplObdVarEntry MEM VarEntry##ind##_##sub##_g; #define EPL_OBD_SUBINDEX_RAM_USERDEF_NOINIT(ind,sub,typ,acc,dtyp,name) static tEplObdVarEntry VarEntry##ind##_##sub##_g;
//------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------
#elif defined (EPL_OBD_CREATE_SUBINDEX_TAB) #elif defined (EPL_OBD_CREATE_SUBINDEX_TAB)
@ -159,17 +159,17 @@
#define EPL_OBD_END_PART() #define EPL_OBD_END_PART()
//--------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------
#define EPL_OBD_BEGIN_INDEX_RAM(ind,cnt,call) static tEplObdSubEntry MEM aObdSubEntry##ind##Ram_g[cnt]= { #define EPL_OBD_BEGIN_INDEX_RAM(ind,cnt,call) static tEplObdSubEntry aObdSubEntry##ind##Ram_g[cnt]= {
#define EPL_OBD_END_INDEX(ind) EPL_OBD_END_SUBINDEX()}; #define EPL_OBD_END_INDEX(ind) EPL_OBD_END_SUBINDEX()};
#define EPL_OBD_RAM_INDEX_RAM_ARRAY(ind,cnt,call,typ,acc,dtyp,name,def) static tEplObdSubEntry MEM aObdSubEntry##ind##Ram_g[]= { \ #define EPL_OBD_RAM_INDEX_RAM_ARRAY(ind,cnt,call,typ,acc,dtyp,name,def) static tEplObdSubEntry aObdSubEntry##ind##Ram_g[]= { \
{0, kEplObdTypUInt8, kEplObdAccCR, &xDef##ind##_0x00_g, NULL}, \ {0, kEplObdTypUInt8, kEplObdAccCR, &xDef##ind##_0x00_g, NULL}, \
{1, typ, (acc)|kEplObdAccArray, &xDef##ind##_0x01_g, &axCur##ind##_g[0]}, \ {1, typ, (acc)|kEplObdAccArray, &xDef##ind##_0x01_g, &axCur##ind##_g[0]}, \
EPL_OBD_END_SUBINDEX()}; EPL_OBD_END_SUBINDEX()};
#define EPL_OBD_RAM_INDEX_RAM_VARARRAY(ind,cnt,call,typ,acc,dtyp,name,def) static tEplObdSubEntry MEM aObdSubEntry##ind##Ram_g[]= { \ #define EPL_OBD_RAM_INDEX_RAM_VARARRAY(ind,cnt,call,typ,acc,dtyp,name,def) static tEplObdSubEntry aObdSubEntry##ind##Ram_g[]= { \
{0, kEplObdTypUInt8, kEplObdAccCR, &xDef##ind##_0x00_g, NULL}, \ {0, kEplObdTypUInt8, kEplObdAccCR, &xDef##ind##_0x00_g, NULL}, \
{1, typ, (acc)|kEplObdAccArray|kEplObdAccVar, &xDef##ind##_0x01_g, &aVarEntry##ind##_g[0]}, \ {1, typ, (acc)|kEplObdAccArray|kEplObdAccVar, &xDef##ind##_0x01_g, &aVarEntry##ind##_g[0]}, \
EPL_OBD_END_SUBINDEX()}; EPL_OBD_END_SUBINDEX()};
#define EPL_OBD_RAM_INDEX_RAM_VARARRAY_NOINIT(ind,cnt,call,typ,acc,dtyp,name) static tEplObdSubEntry MEM aObdSubEntry##ind##Ram_g[]= { \ #define EPL_OBD_RAM_INDEX_RAM_VARARRAY_NOINIT(ind,cnt,call,typ,acc,dtyp,name) static tEplObdSubEntry aObdSubEntry##ind##Ram_g[]= { \
{0, kEplObdTypUInt8, kEplObdAccCR, &xDef##ind##_0x00_g, NULL}, \ {0, kEplObdTypUInt8, kEplObdAccCR, &xDef##ind##_0x00_g, NULL}, \
{1, typ, (acc)|kEplObdAccArray|kEplObdAccVar, NULL, &aVarEntry##ind##_g[0]}, \ {1, typ, (acc)|kEplObdAccArray|kEplObdAccVar, NULL, &aVarEntry##ind##_g[0]}, \
EPL_OBD_END_SUBINDEX()}; EPL_OBD_END_SUBINDEX()};

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

@ -201,7 +201,7 @@ EPLDLLEXPORT tEplKernel EplObduAccessOdPart(tEplObdPart ObdPart_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduDefineVar(tEplVarParam MEM *pVarParam_p) EPLDLLEXPORT tEplKernel EplObduDefineVar(tEplVarParam *pVarParam_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -274,7 +274,7 @@ EPLDLLEXPORT tEplKernel EplObduRegisterUserOd(tEplObdEntryPtr pUserOd_p)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT void EplObduInitVarEntry(tEplObdVarEntry MEM *pVarEntry_p, EPLDLLEXPORT void EplObduInitVarEntry(tEplObdVarEntry *pVarEntry_p,
BYTE bType_p, tEplObdSize ObdSize_p) BYTE bType_p, tEplObdSize ObdSize_p)
{ {
EplObduCalInitVarEntry(pVarEntry_p, bType_p, ObdSize_p); EplObduCalInitVarEntry(pVarEntry_p, bType_p, ObdSize_p);
@ -473,7 +473,7 @@ EPLDLLEXPORT tEplKernel EplObduWriteEntryFromLe(unsigned int uiIndex_p,
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p, EPLDLLEXPORT tEplKernel EplObduSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiSubindex_p, unsigned int uiSubindex_p,
tEplObdVarEntry MEM **ppVarEntry_p) tEplObdVarEntry **ppVarEntry_p)
{ {
tEplKernel Ret; tEplKernel Ret;

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

@ -212,7 +212,7 @@ EPLDLLEXPORT tEplKernel EplObduCalAccessOdPart(tEplObdPart ObdPart_p,
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduCalDefineVar(tEplVarParam MEM *pVarParam_p) EPLDLLEXPORT tEplKernel EplObduCalDefineVar(tEplVarParam *pVarParam_p)
{ {
tEplKernel Ret; tEplKernel Ret;
@ -296,7 +296,7 @@ EPLDLLEXPORT tEplKernel EplObduCalRegisterUserOd(tEplObdEntryPtr pUserOd_p)
// State: // State:
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT void EplObduCalInitVarEntry(tEplObdVarEntry MEM *pVarEntry_p, EPLDLLEXPORT void EplObduCalInitVarEntry(tEplObdVarEntry *pVarEntry_p,
BYTE bType_p, tEplObdSize ObdSize_p) BYTE bType_p, tEplObdSize ObdSize_p)
{ {
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0) #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
@ -507,7 +507,7 @@ EPLDLLEXPORT tEplKernel EplObduCalWriteEntryFromLe(unsigned int uiIndex_p,
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduCalSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p, EPLDLLEXPORT tEplKernel EplObduCalSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiSubindex_p, unsigned int uiSubindex_p,
tEplObdVarEntry MEM **ppVarEntry_p) tEplObdVarEntry **ppVarEntry_p)
{ {
tEplKernel Ret; tEplKernel Ret;

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

@ -149,7 +149,7 @@
// local function prototypes // local function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel EplPdouCheckPdoValidity(tEplObdCbParam MEM * pParam_p, static tEplKernel EplPdouCheckPdoValidity(tEplObdCbParam *pParam_p,
unsigned int uiIndex_p); unsigned int uiIndex_p);
static void EplPdouDecodeObjectMapping(QWORD qwObjectMapping_p, static void EplPdouDecodeObjectMapping(QWORD qwObjectMapping_p,
@ -226,7 +226,7 @@ tEplKernel EplPdouDelInstance(void)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
tEplKernel EplPdouCbObdAccess(tEplObdCbParam MEM *pParam_p) tEplKernel EplPdouCbObdAccess(tEplObdCbParam *pParam_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;
unsigned int uiPdoId; unsigned int uiPdoId;
@ -394,7 +394,7 @@ tEplKernel EplPdouCbObdAccess(tEplObdCbParam MEM *pParam_p)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
static tEplKernel EplPdouCheckPdoValidity(tEplObdCbParam MEM * pParam_p, static tEplKernel EplPdouCheckPdoValidity(tEplObdCbParam *pParam_p,
unsigned int uiIndex_p) unsigned int uiIndex_p)
{ {
tEplKernel Ret = kEplSuccessful; tEplKernel Ret = kEplSuccessful;

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

@ -188,7 +188,7 @@ 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 EplObdInitRam(tEplObdInitParam MEM * pInitParam_p); tEplKernel EplObdInitRam(tEplObdInitParam *pInitParam_p);
tEplKernel 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)

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

@ -27,12 +27,6 @@
#define QWORD long long int #define QWORD long long int
#endif #endif
// ------------------ GNUC for I386 ---------------------------------------------
#define HWACC // hardware access through external memory (i.e. CAN)
#define MEM // Memory attribute to optimize speed and code of pointer access.
#ifndef CONST #ifndef CONST
#define CONST const // variables mapped to ROM (i.e. flash) #define CONST const // variables mapped to ROM (i.e. flash)
#endif #endif

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

@ -85,17 +85,17 @@
// global variables // global variables
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
extern BYTE MEM abEplObdTrashObject_g[8]; extern BYTE abEplObdTrashObject_g[8];
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// function prototypes // function prototypes
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0) #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObdInit(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitParam MEM *pInitParam_p); EPLDLLEXPORT tEplKernel EplObdInit(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitParam *pInitParam_p);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObdAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitParam MEM *pInitParam_p); EPLDLLEXPORT tEplKernel EplObdAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitParam *pInitParam_p);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObdDeleteInstance(EPL_MCO_DECL_INSTANCE_PTR); EPLDLLEXPORT tEplKernel EplObdDeleteInstance(EPL_MCO_DECL_INSTANCE_PTR);
@ -120,7 +120,7 @@ EPLDLLEXPORT tEplKernel EplObdAccessOdPart(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdPar
tEplObdDir Direction_p); tEplObdDir Direction_p);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObdDefineVar(EPL_MCO_DECL_INSTANCE_PTR_ tEplVarParam MEM *pVarParam_p); EPLDLLEXPORT tEplKernel EplObdDefineVar(EPL_MCO_DECL_INSTANCE_PTR_ tEplVarParam *pVarParam_p);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT void *EplObdGetObjectDataPtr(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p, EPLDLLEXPORT void *EplObdGetObjectDataPtr(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
@ -129,7 +129,7 @@ EPLDLLEXPORT void *EplObdGetObjectDataPtr(EPL_MCO_DECL_INSTANCE_PTR_ unsigned in
EPLDLLEXPORT tEplKernel EplObdRegisterUserOd(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPtr pUserOd_p); EPLDLLEXPORT tEplKernel EplObdRegisterUserOd(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPtr pUserOd_p);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT void EplObdInitVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdVarEntry MEM *pVarEntry_p, EPLDLLEXPORT void EplObdInitVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdVarEntry *pVarEntry_p,
tEplObdType Type_p, tEplObdType Type_p,
tEplObdSize ObdSize_p); tEplObdSize ObdSize_p);
@ -168,7 +168,7 @@ EPLDLLEXPORT tEplKernel EplObdGetAccessType(EPL_MCO_DECL_INSTANCE_PTR_ unsigned
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObdSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p, EPLDLLEXPORT tEplKernel EplObdSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
unsigned int uiSubindex_p, unsigned int uiSubindex_p,
tEplObdVarEntry MEM **ppVarEntry_p); tEplObdVarEntry **ppVarEntry_p);
#endif // end of #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0) #endif // end of #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)

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

@ -107,7 +107,7 @@ EPLDLLEXPORT tEplKernel EplObduAccessOdPart(tEplObdPart ObdPart_p,
tEplObdDir Direction_p); tEplObdDir Direction_p);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduDefineVar(tEplVarParam MEM * pVarParam_p); EPLDLLEXPORT tEplKernel EplObduDefineVar(tEplVarParam *pVarParam_p);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT void *EplObduGetObjectDataPtr(unsigned int uiIndex_p, EPLDLLEXPORT void *EplObduGetObjectDataPtr(unsigned int uiIndex_p,
@ -116,7 +116,7 @@ EPLDLLEXPORT void *EplObduGetObjectDataPtr(unsigned int uiIndex_p,
EPLDLLEXPORT tEplKernel EplObduRegisterUserOd(tEplObdEntryPtr pUserOd_p); EPLDLLEXPORT tEplKernel EplObduRegisterUserOd(tEplObdEntryPtr pUserOd_p);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
EPLDLLEXPORT void EplObduInitVarEntry(tEplObdVarEntry MEM * pVarEntry_p, EPLDLLEXPORT void EplObduInitVarEntry(tEplObdVarEntry *pVarEntry_p,
BYTE bType_p, tEplObdSize ObdSize_p); BYTE bType_p, tEplObdSize ObdSize_p);
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
@ -148,7 +148,7 @@ EPLDLLEXPORT tEplKernel EplObduWriteEntryFromLe(unsigned int uiIndex_p,
EPLDLLEXPORT tEplKernel 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 **ppVarEntry_p);
#elif EPL_OBD_USE_KERNEL != FALSE #elif EPL_OBD_USE_KERNEL != FALSE
#include "../kernel/EplObdk.h" #include "../kernel/EplObdk.h"

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

@ -98,14 +98,14 @@ EPLDLLEXPORT tEplKernel EplObduCalReadEntry(unsigned int uiIndex_p,
EPLDLLEXPORT tEplKernel EplObduCalAccessOdPart(tEplObdPart ObdPart_p, EPLDLLEXPORT tEplKernel EplObduCalAccessOdPart(tEplObdPart ObdPart_p,
tEplObdDir Direction_p); tEplObdDir Direction_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduCalDefineVar(tEplVarParam MEM *pVarParam_p); EPLDLLEXPORT tEplKernel EplObduCalDefineVar(tEplVarParam *pVarParam_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT void *EplObduCalGetObjectDataPtr(unsigned int uiIndex_p, EPLDLLEXPORT void *EplObduCalGetObjectDataPtr(unsigned int uiIndex_p,
unsigned int uiSubIndex_p); unsigned int uiSubIndex_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel EplObduCalRegisterUserOd(tEplObdEntryPtr pUserOd_p); EPLDLLEXPORT tEplKernel EplObduCalRegisterUserOd(tEplObdEntryPtr pUserOd_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT void EplObduCalInitVarEntry(tEplObdVarEntry MEM *pVarEntry_p, EPLDLLEXPORT void EplObduCalInitVarEntry(tEplObdVarEntry *pVarEntry_p,
BYTE bType_p, tEplObdSize ObdSize_p); BYTE bType_p, tEplObdSize ObdSize_p);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
EPLDLLEXPORT tEplObdSize EplObduCalGetDataSize(unsigned int uiIndex_p, EPLDLLEXPORT tEplObdSize EplObduCalGetDataSize(unsigned int uiIndex_p,
@ -133,6 +133,6 @@ EPLDLLEXPORT tEplKernel EplObduCalWriteEntryFromLe(unsigned int uiIndex_p,
EPLDLLEXPORT tEplKernel 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 **ppVarEntry_p);
#endif // #ifndef _EPLOBDUCAL_H_ #endif // #ifndef _EPLOBDUCAL_H_

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 EplPdouCbObdAccess(tEplObdCbParam MEM * pParam_p); tEplKernel EplPdouCbObdAccess(tEplObdCbParam *pParam_p);
#else #else
#define EplPdouCbObdAccess NULL #define EplPdouCbObdAccess NULL
#endif #endif