tEplKernel EplDlluCalIssueRequest(tEplDllReqServiceId Service_p, unsigned int uiNodeId_p, BYTE bSoaFlag1_p) { tEplKernel Ret = kEplSuccessful; // add node to appropriate request queue switch (Service_p) { case kEplDllReqServiceIdent: case kEplDllReqServiceStatus: { tEplEvent Event; tEplDllCalIssueRequest IssueReq; Event.m_EventSink = kEplEventSinkDllkCal; Event.m_EventType = kEplEventTypeDllkIssueReq; IssueReq.m_Service = Service_p; IssueReq.m_uiNodeId = uiNodeId_p; IssueReq.m_bSoaFlag1 = bSoaFlag1_p; Event.m_pArg = &IssueReq; Event.m_uiSize = sizeof(IssueReq); Ret = EplEventuPost(&Event); break; } default: { Ret = kEplDllInvalidParam; goto Exit; } } Exit: return Ret; }
//--------------------------------------------------------------------------- // // Function: EplEventuPostError // // Description: post errorevent from userspace // // // // Parameters: EventSource_p = source-module of the errorevent // EplError_p = code of occured error // uiArgSize_p = size of the argument // pArg_p = pointer to the argument // // // Returns: tEpKernel = errorcode // // // State: // //--------------------------------------------------------------------------- tEplKernel PUBLIC EplEventuPostError(tEplEventSource EventSource_p, tEplKernel EplError_p, unsigned int uiArgSize_p, void* pArg_p) { tEplKernel Ret; BYTE abBuffer[EPL_MAX_EVENT_ARG_SIZE]; tEplEventError* pEventError = (tEplEventError*) abBuffer; tEplEvent EplEvent; Ret = kEplSuccessful; // create argument pEventError->m_EventSource = EventSource_p; pEventError->m_EplError = EplError_p; EPL_MEMCPY(&pEventError->m_Arg, pArg_p, uiArgSize_p); // create event EplEvent.m_EventType = kEplEventTypeError; EplEvent.m_EventSink = kEplEventSinkApi; EPL_MEMSET(&EplEvent.m_NetTime, 0x00, sizeof(EplEvent.m_NetTime)); EplEvent.m_uiSize = (sizeof(EventSource_p)+ sizeof(EplError_p)+ uiArgSize_p); EplEvent.m_pArg = &abBuffer[0]; // post errorevent Ret = EplEventuPost(&EplEvent); return Ret; }
//--------------------------------------------------------------------------- // // Function: EplEventuPostError // // Description: post errorevent from userspace // // // // Parameters: EventSource_p = source-module of the errorevent // EplError_p = code of occurred error // uiArgSize_p = size of the argument // pArg_p = pointer to the argument // // // Returns: tEpKernel = errorcode // // // State: // //--------------------------------------------------------------------------- tEplKernel PUBLIC EplEventuPostError(tEplEventSource EventSource_p, tEplKernel EplError_p, unsigned int uiArgSize_p, void* pArg_p) { tEplKernel Ret; tEplEventError EventError; tEplEvent EplEvent; Ret = kEplSuccessful; // create argument EventError.m_EventSource = EventSource_p; EventError.m_EplError = EplError_p; uiArgSize_p = (unsigned int) min ((size_t) uiArgSize_p, sizeof (EventError.m_Arg)); EPL_MEMCPY(&EventError.m_Arg, pArg_p, uiArgSize_p); // create event EplEvent.m_EventType = kEplEventTypeError; EplEvent.m_EventSink = kEplEventSinkApi; EPL_MEMSET(&EplEvent.m_NetTime, 0x00, sizeof(EplEvent.m_NetTime)); EplEvent.m_uiSize = (memberoffs (tEplEventError, m_Arg) + uiArgSize_p); EplEvent.m_pArg = &EventError; // post errorevent Ret = EplEventuPost(&EplEvent); return Ret; }
//--------------------------------------------------------------------------- // // Function: EplTimeruCbMs // // Description: function to process timer // // // // Parameters: lpParameter = pointer to structur of type tEplTimeruData // // // Returns: (none) // // // State: // //--------------------------------------------------------------------------- static void EplTimeruCbMs(unsigned long ulParameter_p) { tEplKernel Ret = kEplSuccessful; tEplTimeruData *pData; tEplEvent EplEvent; tEplTimerEventArg TimerEventArg; pData = (tEplTimeruData *) ulParameter_p; // call event function TimerEventArg.m_TimerHdl = (tEplTimerHdl) pData; TimerEventArg.m_ulArg = pData->TimerArgument.m_ulArg; EplEvent.m_EventSink = pData->TimerArgument.m_EventSink; EplEvent.m_EventType = kEplEventTypeTimer; EPL_MEMSET(&EplEvent.m_NetTime, 0x00, sizeof(tEplNetTime)); EplEvent.m_pArg = &TimerEventArg; EplEvent.m_uiSize = sizeof(TimerEventArg); Ret = EplEventuPost(&EplEvent); // d.k. do not free memory, user has to call EplTimeruDeleteTimer() //kfree(pData); }
tEplKernel PUBLIC EplTimeruProcess(void) { tTimerEntry* pTimerEntry; DWORD dwTimeoutMs; tEplEvent EplEvent; tEplTimerEventArg TimerEventArg; tEplKernel Ret; Ret = kEplSuccessful; EplTimeruEnterCriticalSection(TIMERU_TIMER_LIST); // calculate elapsed time since start time dwTimeoutMs = EplTimeruGetTickCountMs() - EplTimeruInstance_g.m_dwStartTimeMs; // observe first timer entry in timer list pTimerEntry = EplTimeruInstance_g.m_pTimerListFirst; if (pTimerEntry != NULL) { if (dwTimeoutMs >= pTimerEntry->m_dwTimeoutMs) { // timeout elapsed // remove entry from timer list EplTimeruInstance_g.m_pTimerListFirst = pTimerEntry->m_pNext; // adjust start time EplTimeruInstance_g.m_dwStartTimeMs += pTimerEntry->m_dwTimeoutMs; } else { pTimerEntry = NULL; } } EplTimeruLeaveCriticalSection(TIMERU_TIMER_LIST); if (pTimerEntry != NULL) { // call event function TimerEventArg.m_TimerHdl = (tEplTimerHdl) pTimerEntry; EPL_MEMCPY(&TimerEventArg.m_Arg, &pTimerEntry->m_TimerArg.m_Arg, sizeof (TimerEventArg.m_Arg)); EplEvent.m_EventSink = pTimerEntry->m_TimerArg.m_EventSink; EplEvent.m_EventType = kEplEventTypeTimer; EPL_MEMSET(&EplEvent.m_NetTime, 0x00, sizeof(tEplNetTime)); EplEvent.m_pArg = &TimerEventArg; EplEvent.m_uiSize = sizeof(TimerEventArg); Ret = EplEventuPost(&EplEvent); } return Ret; }
tEplKernel EplDlluCalSoftDeleteNode(unsigned int uiNodeId_p) { tEplKernel Ret = kEplSuccessful; tEplEvent Event; Event.m_EventSink = kEplEventSinkDllkCal; Event.m_EventType = kEplEventTypeDllkSoftDelNode; Event.m_pArg = &uiNodeId_p; Event.m_uiSize = sizeof(uiNodeId_p); Ret = EplEventuPost(&Event); return Ret; }
tEplKernel EplDlluCalAddNode(tEplDllNodeInfo * pNodeInfo_p) { tEplKernel Ret = kEplSuccessful; tEplEvent Event; Event.m_EventSink = kEplEventSinkDllkCal; Event.m_EventType = kEplEventTypeDllkAddNode; Event.m_pArg = pNodeInfo_p; Event.m_uiSize = sizeof(tEplDllNodeInfo); Ret = EplEventuPost(&Event); return Ret; }
//--------------------------------------------------------------------------- // // Function: EplNmtuNmtEvent // // Description: sends the NMT-Event to the NMT-State-Maschine // // // // Parameters: NmtEvent_p = NMT-Event to send // // // Returns: tEplKernel = errorcode // // // State: // //--------------------------------------------------------------------------- EPLDLLEXPORT tEplKernel PUBLIC EplNmtuNmtEvent(tEplNmtEvent NmtEvent_p) { tEplKernel Ret; tEplEvent Event; Event.m_EventSink = kEplEventSinkNmtk; Event.m_NetTime.m_dwNanoSec = 0; Event.m_NetTime.m_dwSec = 0; Event.m_EventType = kEplEventTypeNmtEvent; Event.m_pArg = &NmtEvent_p; Event.m_uiSize = sizeof(NmtEvent_p); Ret = EplEventuPost(&Event); return Ret; }
static tEplKernel EplDlluCalSetAsndServiceIdFilter(tEplDllAsndServiceId ServiceId_p, tEplDllAsndFilter Filter_p) { tEplKernel Ret = kEplSuccessful; tEplEvent Event; tEplDllCalAsndServiceIdFilter ServFilter; Event.m_EventSink = kEplEventSinkDllkCal; Event.m_EventType = kEplEventTypeDllkServFilter; ServFilter.m_ServiceId = ServiceId_p; ServFilter.m_Filter = Filter_p; Event.m_pArg = &ServFilter; Event.m_uiSize = sizeof(ServFilter); Ret = EplEventuPost(&Event); return Ret; }
//--------------------------------------------------------------------------- // // Function: EplSdoTimeruThreadms // // Description: function to process timer as thread // // // // Parameters: lpParameter = pointer to structur of type tEplTimeruThread // // // Returns: DWORD = Errorcode // // // State: // //--------------------------------------------------------------------------- DWORD PUBLIC EplSdoTimeruThreadms(LPVOID lpParameter) { tEplKernel Ret; tEplTimeruThread *pThreadData; HANDLE aHandles[2]; BOOL fReturn; LARGE_INTEGER TimeoutTime; unsigned long ulEvent; tEplEvent EplEvent; tEplTimeruThread ThreadData; tEplTimerEventArg TimerEventArg; Ret = kEplSuccessful; // get pointer to data pThreadData = (tEplTimeruThread *) lpParameter; // copy thread data EPL_MEMCPY(&ThreadData, pThreadData, sizeof(ThreadData)); pThreadData = &ThreadData; // leave critical section LeaveCriticalSection(EplTimeruInstance_g.m_pCriticalSection); // create waitable timer aHandles[1] = CreateWaitableTimer(NULL, FALSE, NULL); if (aHandles[1] == NULL) { Ret = kEplTimerNoTimerCreated; goto Exit; } // set timer // set timeout interval -> needed to be negativ // -> because relative timeout // -> multiply by 10000 for 100 ns timebase of function TimeoutTime.QuadPart = (((long long)pThreadData->ulTimeout) * -10000); fReturn = SetWaitableTimer(aHandles[1], &TimeoutTime, 0, NULL, NULL, FALSE); if (fReturn == 0) { Ret = kEplTimerNoTimerCreated; goto Exit; } // save delte event handle in handle array aHandles[0] = pThreadData->DelteHandle; // wait for one of the events ulEvent = WaitForMultipleObjects(2, &aHandles[0], FALSE, INFINITE); if (ulEvent == WAIT_OBJECT_0) { // delte event // close handels CloseHandle(aHandles[1]); // terminate thread goto Exit; } else if (ulEvent == (WAIT_OBJECT_0 + 1)) { // timer event // call event function TimerEventArg.m_TimerHdl = (tEplTimerHdl) pThreadData->DelteHandle; TimerEventArg.m_ulArg = pThreadData->TimerArgument.m_ulArg; EplEvent.m_EventSink = pThreadData->TimerArgument.m_EventSink; EplEvent.m_EventType = kEplEventTypeTimer; EPL_MEMSET(&EplEvent.m_NetTime, 0x00, sizeof(tEplNetTime)); EplEvent.m_pArg = &TimerEventArg; EplEvent.m_uiSize = sizeof(TimerEventArg); Ret = EplEventuPost(&EplEvent); // close handels CloseHandle(aHandles[1]); // terminate thread goto Exit; } else { // error ulEvent = GetLastError(); TRACE1("Error in WaitForMultipleObjects Errorcode: 0x%x\n", ulEvent); // terminate thread goto Exit; } Exit: return Ret; }