tEplKernel EplObdCdcLoadFile(char* pszCdcFilename_p)
{
tEplKernel Ret = kEplSuccessful;
tEplObdCdcInfo CdcInfo;
DWORD dwErrno;
EPL_MEMSET(&CdcInfo, 0, sizeof (CdcInfo));
CdcInfo.m_Type = kEplObdCdcTypeFile;
CdcInfo.m_Handle.m_hCdcFile = open(pszCdcFilename_p, O_RDONLY | O_BINARY, 0666);
if (!IS_FD_VALID(CdcInfo.m_Handle.m_hCdcFile))
{ // error occurred
dwErrno = (DWORD) errno;
Ret = EplEventuPostError(kEplEventSourceObdu, kEplObdErrnoSet, sizeof (dwErrno), &dwErrno);
goto Exit;
}
CdcInfo.m_iCdcSize = lseek(CdcInfo.m_Handle.m_hCdcFile, 0, SEEK_END);
lseek(CdcInfo.m_Handle.m_hCdcFile, 0, SEEK_SET);
Ret = EplObdCdcProcess(&CdcInfo);
if (CdcInfo.m_pbCurBuffer != NULL)
{
EPL_FREE(CdcInfo.m_pbCurBuffer);
CdcInfo.m_pbCurBuffer = NULL;
CdcInfo.m_iBufferSize = 0;
}
close(CdcInfo.m_Handle.m_hCdcFile);
Exit:
return Ret;
}
static void EplEventuRxSignalHandlerCb (
tShbInstance pShbRxInstance_p,
unsigned long ulDataSize_p)
{
tEplEvent *pEplEvent;
tShbError ShbError;
BYTE* pabDataBuffer;
TGT_DBG_SIGNAL_TRACE_POINT(21);
pabDataBuffer = &EplEventuInstance_g.m_abRxBuffer[0];
// copy data from event queue
ShbError = ShbCirReadDataBlock (pShbRxInstance_p,
pabDataBuffer,
sizeof(EplEventuInstance_g.m_abRxBuffer),
&ulDataSize_p);
if(ShbError != kShbOk)
{
EplEventuPostError(kEplEventSourceEventu, kEplEventReadError, sizeof (ShbError), &ShbError);
// error goto exit
goto Exit;
}
// resolve the pointer to the event structure
pEplEvent = (tEplEvent *) pabDataBuffer;
// set Datasize
pEplEvent->m_uiSize = (ulDataSize_p - sizeof(tEplEvent));
if(pEplEvent->m_uiSize > 0)
{
// set pointer to argument
pEplEvent->m_pArg = &pabDataBuffer[sizeof(tEplEvent)];
}
else
{
//set pointer to NULL
pEplEvent->m_pArg = NULL;
}
BENCHMARK_MOD_28_SET(1);
// call processfunction
EplEventuProcess(pEplEvent);
BENCHMARK_MOD_28_RESET(1);
Exit:
return;
}
tEplKernel EplObdCdcLoadBuffer(BYTE* pbCdc_p, unsigned int uiCdcSize_p)
{
tEplKernel Ret = kEplSuccessful;
tEplObdCdcInfo CdcInfo;
EPL_MEMSET(&CdcInfo, 0, sizeof (CdcInfo));
CdcInfo.m_Type = kEplObdCdcTypeBuffer;
CdcInfo.m_Handle.m_pbNextBuffer = pbCdc_p;
if (CdcInfo.m_Handle.m_pbNextBuffer == NULL)
{ // error occurred
Ret = EplEventuPostError(kEplEventSourceObdu, kEplObdInvalidDcf, 0, NULL);
goto Exit;
}
CdcInfo.m_iCdcSize = (size_t) uiCdcSize_p;
CdcInfo.m_iBufferSize = CdcInfo.m_iCdcSize;
Ret = EplObdCdcProcess(&CdcInfo);
Exit:
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplEventuProcess
//
// Description: Kernelthread that dispatches events in kernelspace
//
//
//
// Parameters: pEvent_p = pointer to event-structur from buffer
//
//
// Returns: tEpKernel = errorcode
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel PUBLIC EplEventuProcess(tEplEvent* pEvent_p)
{
tEplKernel Ret;
tEplEventSource EventSource;
Ret = kEplSuccessful;
// check m_EventSink
switch(pEvent_p->m_EventSink)
{
// NMT-User-Module
case kEplEventSinkNmtu:
{
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0)
Ret = EplNmtuProcessEvent(pEvent_p);
if ((Ret != kEplSuccessful) && (Ret != kEplShutdown))
{
EventSource = kEplEventSourceNmtu;
// Error event for API layer
EplEventuPostError(kEplEventSourceEventu,
Ret,
sizeof(EventSource),
&EventSource);
}
#endif
break;
}
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
// NMT-MN-User-Module
case kEplEventSinkNmtMnu:
{
Ret = EplNmtMnuProcessEvent(pEvent_p);
if ((Ret != kEplSuccessful) && (Ret != kEplShutdown))
{
EventSource = kEplEventSourceNmtMnu;
// Error event for API layer
EplEventuPostError(kEplEventSourceEventu,
Ret,
sizeof(EventSource),
&EventSource);
}
break;
}
#endif
#if ((((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0) \
|| (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOS)) != 0))
// events for asynchronus SDO Sequence Layer
case kEplEventSinkSdoAsySeq:
{
Ret = EplSdoAsySeqProcessEvent(pEvent_p);
if ((Ret != kEplSuccessful) && (Ret != kEplShutdown))
{
EventSource = kEplEventSourceSdoAsySeq;
// Error event for API layer
EplEventuPostError(kEplEventSourceEventu,
Ret,
sizeof(EventSource),
&EventSource);
}
break;
}
#endif
// LED user part module
case kEplEventSinkLedu:
{
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0)
Ret = EplLeduProcessEvent(pEvent_p);
if ((Ret != kEplSuccessful) && (Ret != kEplShutdown))
{
EventSource = kEplEventSourceLedu;
// Error event for API layer
EplEventuPostError(kEplEventSourceEventu,
Ret,
sizeof(EventSource),
&EventSource);
}
#endif
break;
}
// event for EPL api
case kEplEventSinkApi:
{
if (EplEventuInstance_g.m_pfnApiProcessEventCb != NULL)
{
Ret = EplEventuInstance_g.m_pfnApiProcessEventCb(pEvent_p);
if ((Ret != kEplSuccessful) && (Ret != kEplShutdown))
{
EventSource = kEplEventSourceEplApi;
// Error event for API layer
EplEventuPostError(kEplEventSourceEventu,
Ret,
sizeof(EventSource),
&EventSource);
}
}
break;
}
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLU)) != 0)
case kEplEventSinkDlluCal:
{
Ret = EplDlluCalProcess(pEvent_p);
if ((Ret != kEplSuccessful) && (Ret != kEplShutdown))
{
EventSource = kEplEventSourceDllu;
// Error event for API layer
EplEventuPostError(kEplEventSourceEventu,
Ret,
sizeof(EventSource),
&EventSource);
}
break;
}
#endif
case kEplEventSinkErru:
{
/*
Ret = EplErruProcess(pEvent_p);
if ((Ret != kEplSuccessful) && (Ret != kEplShutdown))
{
EventSource = kEplEventSourceErru;
// Error event for API layer
EplEventuPostError(kEplEventSourceEventu,
Ret,
sizeof(EventSource),
&EventSource);
}
*/
break;
}
// unknown sink
default:
{
Ret = kEplEventUnknownSink;
// Error event for API layer
EplEventuPostError(kEplEventSourceEventu,
Ret,
sizeof(pEvent_p->m_EventSink),
&pEvent_p->m_EventSink);
}
} // end of switch(pEvent_p->m_EventSink)
return Ret;
}
static tEplKernel EplObdCdcProcess(tEplObdCdcInfo* pCdcInfo_p)
{
tEplKernel Ret = kEplSuccessful;
DWORD dwEntriesRemaining;
unsigned int uiObjectIndex;
unsigned int uiObjectSubIndex;
size_t iCurDataSize;
Ret = EplObdCdcLoadNextBuffer(pCdcInfo_p, sizeof (DWORD));
if (Ret != kEplSuccessful)
{
goto Exit;
}
dwEntriesRemaining = AmiGetDwordFromLe(pCdcInfo_p->m_pbCurBuffer);
if (dwEntriesRemaining == 0)
{
Ret = EplEventuPostError(kEplEventSourceObdu, kEplObdNoConfigData, 0, NULL);
goto Exit;
}
for ( ; dwEntriesRemaining != 0; dwEntriesRemaining--)
{
Ret = EplObdCdcLoadNextBuffer(pCdcInfo_p, EPL_CDC_OFFSET_DATA);
if (Ret != kEplSuccessful)
{
goto Exit;
}
uiObjectIndex = AmiGetWordFromLe(&pCdcInfo_p->m_pbCurBuffer[EPL_CDC_OFFSET_INDEX]);
uiObjectSubIndex = AmiGetByteFromLe(&pCdcInfo_p->m_pbCurBuffer[EPL_CDC_OFFSET_SUBINDEX]);
iCurDataSize = (size_t) AmiGetDwordFromLe(&pCdcInfo_p->m_pbCurBuffer[EPL_CDC_OFFSET_SIZE]);
EPL_DBGLVL_OBD_TRACE("%s: Reading object 0x%04X/%u with size %u from CDC\n", __func__, uiObjectIndex, uiObjectSubIndex, iCurDataSize);
Ret = EplObdCdcLoadNextBuffer(pCdcInfo_p, iCurDataSize);
if (Ret != kEplSuccessful)
{
EPL_DBGLVL_OBD_TRACE("%s: Reading the corresponding data from CDC failed with 0x%02X\n", __func__, Ret);
goto Exit;
}
Ret = EplObdWriteEntryFromLe(uiObjectIndex, uiObjectSubIndex, pCdcInfo_p->m_pbCurBuffer, (tEplObdSize) iCurDataSize);
if (Ret != kEplSuccessful)
{
tEplEventObdError ObdError;
ObdError.m_uiIndex = uiObjectIndex;
ObdError.m_uiSubIndex = uiObjectSubIndex;
EPL_DBGLVL_OBD_TRACE("%s: Writing object 0x%04X/%u to local OBD failed with 0x%02X\n", __func__, uiObjectIndex, uiObjectSubIndex, Ret);
Ret = EplEventuPostError(kEplEventSourceObdu, Ret, sizeof (ObdError), &ObdError);
if (Ret != kEplSuccessful)
{
goto Exit;
}
}
}
Exit:
return Ret;
}
static tEplKernel EplObdCdcLoadNextBuffer(tEplObdCdcInfo* pCdcInfo_p, size_t iBufferSize)
{
tEplKernel Ret = kEplSuccessful;
int iReadSize;
BYTE* pbBuffer;
switch (pCdcInfo_p->m_Type)
{
case kEplObdCdcTypeFile:
{
if (pCdcInfo_p->m_iBufferSize < iBufferSize)
{
if (pCdcInfo_p->m_pbCurBuffer != NULL)
{
EPL_FREE(pCdcInfo_p->m_pbCurBuffer);
pCdcInfo_p->m_pbCurBuffer = NULL;
pCdcInfo_p->m_iBufferSize = 0;
}
pCdcInfo_p->m_pbCurBuffer = EPL_MALLOC(iBufferSize);
if (pCdcInfo_p->m_pbCurBuffer == NULL)
{
Ret = EplEventuPostError(kEplEventSourceObdu, kEplObdOutOfMemory, 0, NULL);
if (Ret != kEplSuccessful)
{
goto Exit;
}
Ret = kEplReject;
goto Exit;
}
pCdcInfo_p->m_iBufferSize = iBufferSize;
}
pbBuffer = pCdcInfo_p->m_pbCurBuffer;
do
{
iReadSize = read(pCdcInfo_p->m_Handle.m_hCdcFile, pbBuffer, iBufferSize);
if (iReadSize <= 0)
{
Ret = EplEventuPostError(kEplEventSourceObdu, kEplObdInvalidDcf, 0, NULL);
if (Ret != kEplSuccessful)
{
goto Exit;
}
Ret = kEplReject;
goto Exit;
}
pbBuffer += iReadSize;
iBufferSize -= iReadSize;
pCdcInfo_p->m_iCdcSize -= iReadSize;
}
while (iBufferSize > 0);
break;
}
case kEplObdCdcTypeBuffer:
{
if (pCdcInfo_p->m_iBufferSize < iBufferSize)
{
Ret = EplEventuPostError(kEplEventSourceObdu, kEplObdInvalidDcf, 0, NULL);
if (Ret != kEplSuccessful)
{
goto Exit;
}
Ret = kEplReject;
goto Exit;
}
pCdcInfo_p->m_pbCurBuffer = pCdcInfo_p->m_Handle.m_pbNextBuffer;
pCdcInfo_p->m_Handle.m_pbNextBuffer += iBufferSize;
pCdcInfo_p->m_iBufferSize -= iBufferSize;
break;
}
}
Exit:
return Ret;
}
