//------------------------------------------------------------------------------
static tOplkError loadCdcFile(char* pCdcFilename_p)
{
tOplkError ret = kErrorOk;
tObdCdcInfo cdcInfo;
UINT32 error;
OPLK_MEMSET(&cdcInfo, 0, sizeof(tObdCdcInfo));
cdcInfo.type = kObdCdcTypeFile;
cdcInfo.handle.fdCdcFile = open(pCdcFilename_p, O_RDONLY | O_BINARY, 0666);
if (!IS_FD_VALID(cdcInfo.handle.fdCdcFile))
{ // error occurred
error = (UINT32)errno;
ret = eventu_postError(kEventSourceObdu, kErrorObdErrnoSet, sizeof(UINT32), &error);
return ret;
}
cdcInfo.cdcSize = lseek(cdcInfo.handle.fdCdcFile, 0, SEEK_END);
lseek(cdcInfo.handle.fdCdcFile, 0, SEEK_SET);
ret = processCdc(&cdcInfo);
if (cdcInfo.pCurBuffer != NULL)
{
OPLK_FREE(cdcInfo.pCurBuffer);
cdcInfo.pCurBuffer = NULL;
cdcInfo.bufferSize = 0;
}
close(cdcInfo.handle.fdCdcFile);
return ret;
}
//---------------------------------------------------------------------------
//
// Function: EplLinExit
//
// Description: Exit point of kernel module
////
//
// Parameters: N/A
//
//
// Returns: Return code
//
//---------------------------------------------------------------------------
static void __exit EplLinExit (void)
{
tEplKernel EplRet;
// halt the NMT state machine
// so the processing of POWERLINK frames stops
EplRet = EplApiExecNmtCommand(kEplNmtEventSwitchOff);
// wait until NMT state machine is shut down
wait_event_interruptible(WaitQueueShutdown_g,
(atomic_read(&AtomicShutdown_g) == TRUE));
/* if ((iErr != 0) || (atomic_read(&AtomicShutdown_g) == EVENT_STATE_IOCTL))
{ // waiting was interrupted by signal or application called wrong function
EplRet = kEplShutdown;
}*/
// Free resources used by the process image API
EplRet = EplApiProcessImageFree();
// delete instance for all modules
EplRet = EplApiShutdown();
PRINTF("EplApiShutdown(): 0x%X\n", EplRet);
// deinitialize proc fs
EplRet = EplLinProcFree();
PRINTF("EplLinProcFree(): 0x%X\n", EplRet);
if (IS_FD_VALID(hAppFdTracingEnabled_g))
{
close(hAppFdTracingEnabled_g);
}
}
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;
}
tEplKernel PUBLIC AppCbEvent(
tEplApiEventType eventType_p, // IN: event type (enum)
tEplApiEventArg* pEventArg_p, // IN: event argument (union)
void GENERIC* pUserArg_p)
{
tEplKernel EplRet = kEplSuccessful;
UNUSED_PARAMETER(pUserArg_p);
// check if NMT_GS_OFF is reached
switch (eventType_p)
{
case kEplApiEventNmtStateChange:
{
switch (pEventArg_p->m_NmtStateChange.m_NewNmtState)
{
case kEplNmtGsOff:
{ // NMT state machine was shut down,
// because of user signal (CTRL-C) or critical EPL stack error
// -> also shut down EplApiProcess() and main()
EplRet = kEplShutdown;
PRINTF("%s(kEplNmtGsOff) originating event = 0x%X\n", __func__, pEventArg_p->m_NmtStateChange.m_NmtEvent);
// wake up EplLinExit()
atomic_set(&AtomicShutdown_g, TRUE);
wake_up_interruptible(&WaitQueueShutdown_g);
break;
}
case kEplNmtGsResetCommunication:
{
// continue
}
case kEplNmtGsResetConfiguration:
{
if (uiCycleLen_g != 0)
{
EplRet = EplApiWriteLocalObject(0x1006, 0x00, &uiCycleLen_g, sizeof (uiCycleLen_g));
}
// continue
}
case kEplNmtMsPreOperational1:
{
PRINTF("%s(0x%X -> 0x%X) originating event = 0x%X\n",
__func__,
pEventArg_p->m_NmtStateChange.m_OldNmtState,
pEventArg_p->m_NmtStateChange.m_NewNmtState,
pEventArg_p->m_NmtStateChange.m_NmtEvent);
// continue
}
case kEplNmtGsInitialising:
case kEplNmtGsResetApplication:
case kEplNmtMsNotActive:
case kEplNmtCsNotActive:
case kEplNmtCsPreOperational1:
{
break;
}
case kEplNmtCsOperational:
case kEplNmtMsOperational:
{
break;
}
default:
{
break;
}
}
break;
}
case kEplApiEventCriticalError:
case kEplApiEventWarning:
{ // error or warning occurred within the stack or the application
// on error the API layer stops the NMT state machine
PRINTF("%s(Err/Warn): Source=%02X EplError=0x%03X",
__func__,
pEventArg_p->m_InternalError.m_EventSource,
pEventArg_p->m_InternalError.m_EplError);
// check additional argument
switch (pEventArg_p->m_InternalError.m_EventSource)
{
case kEplEventSourceEventk:
case kEplEventSourceEventu:
{ // error occurred within event processing
// either in kernel or in user part
PRINTF(" OrgSource=%02X\n", pEventArg_p->m_InternalError.m_Arg.m_EventSource);
break;
}
case kEplEventSourceDllk:
{ // error occurred within the data link layer (e.g. interrupt processing)
// the DWORD argument contains the DLL state and the NMT event
PRINTF(" val=%lX\n", (ULONG) pEventArg_p->m_InternalError.m_Arg.m_dwArg);
break;
}
case kEplEventSourceObdk:
case kEplEventSourceObdu:
{ // error occurred within OBD module
// either in kernel or in user part
PRINTF(" Object=0x%04X/%u\n", pEventArg_p->m_InternalError.m_Arg.m_ObdError.m_uiIndex, pEventArg_p->m_InternalError.m_Arg.m_ObdError.m_uiSubIndex);
break;
}
default:
{
PRINTF("\n");
break;
}
}
break;
}
case kEplApiEventHistoryEntry:
{ // new history entry
if ((pEventArg_p->m_ErrHistoryEntry.m_wErrorCode == EPL_E_DLL_CYCLE_EXCEED_TH)
&& (IS_FD_VALID(hAppFdTracingEnabled_g)))
{
mm_segment_t old_fs;
loff_t pos;
ssize_t iRet;
old_fs = get_fs();
set_fs(KERNEL_DS);
pos = hAppFdTracingEnabled_g->f_pos;
iRet = vfs_write(hAppFdTracingEnabled_g, "0", 1, &pos);
hAppFdTracingEnabled_g->f_pos = pos;
}
PRINTF("%s(HistoryEntry): Type=0x%04X Code=0x%04X (0x%02X %02X %02X %02X %02X %02X %02X %02X)\n",
__func__,
pEventArg_p->m_ErrHistoryEntry.m_wEntryType,
pEventArg_p->m_ErrHistoryEntry.m_wErrorCode,
(WORD) pEventArg_p->m_ErrHistoryEntry.m_abAddInfo[0],
(WORD) pEventArg_p->m_ErrHistoryEntry.m_abAddInfo[1],
(WORD) pEventArg_p->m_ErrHistoryEntry.m_abAddInfo[2],
(WORD) pEventArg_p->m_ErrHistoryEntry.m_abAddInfo[3],
(WORD) pEventArg_p->m_ErrHistoryEntry.m_abAddInfo[4],
(WORD) pEventArg_p->m_ErrHistoryEntry.m_abAddInfo[5],
(WORD) pEventArg_p->m_ErrHistoryEntry.m_abAddInfo[6],
(WORD) pEventArg_p->m_ErrHistoryEntry.m_abAddInfo[7]);
break;
}
case kEplApiEventNode:
{
// check additional argument
switch (pEventArg_p->m_Node.m_NodeEvent)
{
case kEplNmtNodeEventCheckConf:
{
PRINTF("%s(Node=0x%X, CheckConf)\n", __func__, pEventArg_p->m_Node.m_uiNodeId);
break;
}
case kEplNmtNodeEventUpdateConf:
{
PRINTF("%s(Node=0x%X, UpdateConf)\n", __func__, pEventArg_p->m_Node.m_uiNodeId);
break;
}
case kEplNmtNodeEventNmtState:
{
PRINTF("%s(Node=0x%X, NmtState=0x%X)\n", __func__, pEventArg_p->m_Node.m_uiNodeId, pEventArg_p->m_Node.m_NmtState);
break;
}
case kEplNmtNodeEventError:
{
PRINTF("%s (Node=0x%X): Error = %s (0x%.4X)\n", __func__,
pEventArg_p->m_Node.m_uiNodeId,
EplGetEmergErrCodeStr(pEventArg_p->m_Node.m_wErrorCode),
pEventArg_p->m_Node.m_wErrorCode);
break;
}
case kEplNmtNodeEventFound:
{
PRINTF("%s(Node=0x%X, Found)\n", __func__, pEventArg_p->m_Node.m_uiNodeId);
break;
}
default:
{
break;
}
}
break;
}
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_CFM)) != 0)
case kEplApiEventCfmProgress:
{
PRINTF("%s(Node=0x%X, CFM-Progress: Object 0x%X/%u, ", __func__, pEventArg_p->m_CfmProgress.m_uiNodeId, pEventArg_p->m_CfmProgress.m_uiObjectIndex, pEventArg_p->m_CfmProgress.m_uiObjectSubIndex);
PRINTF("%lu/%lu Bytes", (ULONG) pEventArg_p->m_CfmProgress.m_dwBytesDownloaded, (ULONG) pEventArg_p->m_CfmProgress.m_dwTotalNumberOfBytes);
if ((pEventArg_p->m_CfmProgress.m_dwSdoAbortCode != 0)
|| (pEventArg_p->m_CfmProgress.m_EplError != kEplSuccessful))
{
PRINTF(" -> SDO Abort=0x%lX, Error=0x%X)\n", (unsigned long) pEventArg_p->m_CfmProgress.m_dwSdoAbortCode,
pEventArg_p->m_CfmProgress.m_EplError);
}
else
{
PRINTF(")\n");
}
break;
}
case kEplApiEventCfmResult:
{
switch (pEventArg_p->m_CfmResult.m_NodeCommand)
{
case kEplNmtNodeCommandConfOk:
{
PRINTF("%s(Node=0x%X, ConfOk)\n", __func__, pEventArg_p->m_CfmResult.m_uiNodeId);
break;
}
case kEplNmtNodeCommandConfErr:
{
PRINTF("%s(Node=0x%X, ConfErr)\n", __func__, pEventArg_p->m_CfmResult.m_uiNodeId);
break;
}
case kEplNmtNodeCommandConfReset:
{
PRINTF("%s(Node=0x%X, ConfReset)\n", __func__, pEventArg_p->m_CfmResult.m_uiNodeId);
break;
}
case kEplNmtNodeCommandConfRestored:
{
PRINTF("%s(Node=0x%X, ConfRestored)\n", __func__, pEventArg_p->m_CfmResult.m_uiNodeId);
break;
}
default:
{
PRINTF("%s(Node=0x%X, CfmResult=0x%X)\n", __func__, pEventArg_p->m_CfmResult.m_uiNodeId, pEventArg_p->m_CfmResult.m_NodeCommand);
break;
}
}
break;
}
#endif
default:
break;
}
return EplRet;
}