/****************************************************************************
(c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29
www.systec-electronic.com
Project: openPOWERLINK
Description: source file for error handler module
License:
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of SYSTEC electronic GmbH nor the names of its
contributors may be used to endorse or promote products derived
from this software without prior written permission. For written
permission, please contact info@systec-electronic.com.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
Severability Clause:
If a provision of this License is or becomes illegal, invalid or
unenforceable in any jurisdiction, that shall not affect:
1. the validity or enforceability in that jurisdiction of any other
provision of this License; or
2. the validity or enforceability in other jurisdictions of that or
any other provision of this License.
-------------------------------------------------------------------------
$RCSfile: EplErrorHandlerk.c,v $
$Author: D.Krueger $
$Revision: 1.9 $ $Date: 2008/10/17 15:32:32 $
$State: Exp $
Build Environment:
GCC V3.4
-------------------------------------------------------------------------
Revision History:
2006/10/02 d.k.: start of the implementation
****************************************************************************/
#include "kernel/EplErrorHandlerk.h"
#include "EplNmt.h"
#include "kernel/EplEventk.h"
#include "kernel/EplObdk.h" // function prototyps of the EplOBD-Modul
#include "kernel/EplDllk.h"
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) == 0)
#error "EPL ErrorHandler module needs EPL module OBDK!"
#endif
/***************************************************************************/
/* */
/* */
/* G L O B A L D E F I N I T I O N S */
/* */
/* */
/***************************************************************************/
//---------------------------------------------------------------------------
// const defines
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// local types
//---------------------------------------------------------------------------
typedef struct {
u32 m_dwCumulativeCnt; // subindex 1
u32 m_dwThresholdCnt; // subindex 2
u32 m_dwThreshold; // subindex 3
} tEplErrorHandlerkErrorCounter;
typedef struct {
tEplErrorHandlerkErrorCounter m_CnLossSoc; // object 0x1C0B
tEplErrorHandlerkErrorCounter m_CnLossPreq; // object 0x1C0D
tEplErrorHandlerkErrorCounter m_CnCrcErr; // object 0x1C0F
unsigned long m_ulDllErrorEvents;
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
tEplErrorHandlerkErrorCounter m_MnCrcErr; // object 0x1C00
tEplErrorHandlerkErrorCounter m_MnCycTimeExceed; // object 0x1C02
u32 m_adwMnCnLossPresCumCnt[254]; // object 0x1C07
u32 m_adwMnCnLossPresThrCnt[254]; // object 0x1C08
u32 m_adwMnCnLossPresThreshold[254]; // object 0x1C09
BOOL m_afMnCnLossPresEvent[254];
#endif
} tEplErrorHandlerkInstance;
//---------------------------------------------------------------------------
// modul globale vars
//---------------------------------------------------------------------------
static tEplErrorHandlerkInstance EplErrorHandlerkInstance_g;
//---------------------------------------------------------------------------
// local function prototypes
//---------------------------------------------------------------------------
static tEplKernel EplErrorHandlerkLinkErrorCounter(tEplErrorHandlerkErrorCounter
* pErrorCounter_p,
unsigned int uiIndex_p);
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
static tEplKernel EplErrorHandlerkLinkArray(u32 * pdwValue_p,
unsigned int uiValueCount_p,
unsigned int uiIndex_p);
#endif
/***************************************************************************/
/* */
/* */
/* C L A S S <Epl-Kernelspace-Error-Handler> */
/* */
/* */
/***************************************************************************/
//
// Description:
//
//
/***************************************************************************/
//=========================================================================//
// //
// P U B L I C F U N C T I O N S //
// //
//=========================================================================//
//---------------------------------------------------------------------------
//
// Function: EplErrorHandlerkInit
//
// Description: function initialize the first instance
//
//
//
// Parameters:
//
//
// Returns: tEpKernel = errorcode
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplErrorHandlerkInit(void)
{
tEplKernel Ret;
Ret = EplErrorHandlerkAddInstance();
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplErrorHandlerkAddInstance
//
// Description: function add one more instance
//
//
//
// Parameters:
//
//
// Returns: tEpKernel = errorcode
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplErrorHandlerkAddInstance(void)
{
tEplKernel Ret;
Ret = kEplSuccessful;
// reset only event variable,
// all other instance members are reset by OD or may keep their current value
// d.k.: this is necessary for the cumulative counters, which shall not be reset
EplErrorHandlerkInstance_g.m_ulDllErrorEvents = 0;
// link counters to OD
// $$$ d.k. if OD resides in userspace, fetch pointer to shared memory,
// which shall have the same structure as the instance (needs to be declared globally).
// Other idea: error counter shall belong to the process image
// (reset of counters by SDO write are a little bit tricky).
Ret =
EplErrorHandlerkLinkErrorCounter(&EplErrorHandlerkInstance_g.
m_CnLossSoc, 0x1C0B);
if (Ret != kEplSuccessful) {
goto Exit;
}
Ret =
EplErrorHandlerkLinkErrorCounter(&EplErrorHandlerkInstance_g.
m_CnLossPreq, 0x1C0D);
// ignore return code, because object 0x1C0D is conditional
Ret =
EplErrorHandlerkLinkErrorCounter(&EplErrorHandlerkInstance_g.
m_CnCrcErr, 0x1C0F);
if (Ret != kEplSuccessful) {
goto Exit;
}
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
Ret =
EplErrorHandlerkLinkErrorCounter(&EplErrorHandlerkInstance_g.
m_MnCrcErr, 0x1C00);
if (Ret != kEplSuccessful) {
goto Exit;
}
Ret =
EplErrorHandlerkLinkErrorCounter(&EplErrorHandlerkInstance_g.
m_MnCycTimeExceed, 0x1C02);
if (Ret != kEplSuccessful) {
goto Exit;
}
Ret =
EplErrorHandlerkLinkArray(EplErrorHandlerkInstance_g.
m_adwMnCnLossPresCumCnt,
tabentries(EplErrorHandlerkInstance_g.
m_adwMnCnLossPresCumCnt),
0x1C07);
if (Ret != kEplSuccessful) {
goto Exit;
}
Ret =
EplErrorHandlerkLinkArray(EplErrorHandlerkInstance_g.
m_adwMnCnLossPresThrCnt,
tabentries(EplErrorHandlerkInstance_g.
m_adwMnCnLossPresThrCnt),
0x1C08);
if (Ret != kEplSuccessful) {
goto Exit;
}
Ret =
EplErrorHandlerkLinkArray(EplErrorHandlerkInstance_g.
m_adwMnCnLossPresThreshold,
tabentries(EplErrorHandlerkInstance_g.
m_adwMnCnLossPresThreshold),
0x1C09);
if (Ret != kEplSuccessful) {
goto Exit;
}
#endif
Exit:
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplErrorHandlerkDelInstance
//
// Description: function delete instance an free the bufferstructure
//
//
//
// Parameters:
//
//
// Returns: tEpKernel = errorcode
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplErrorHandlerkDelInstance(void)
{
tEplKernel Ret;
Ret = kEplSuccessful;
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplErrorHandlerkProcess
//
// Description: processes error events from DLL
//
//
//
// Parameters: pEvent_p = pointer to event-structur from buffer
//
//
// Returns: tEpKernel = errorcode
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplErrorHandlerkProcess(tEplEvent *pEvent_p)
{
tEplKernel Ret;
unsigned long ulDllErrorEvents;
tEplEvent Event;
tEplNmtEvent NmtEvent;
Ret = kEplSuccessful;
// check m_EventType
switch (pEvent_p->m_EventType) {
case kEplEventTypeDllError:
{
tEplErrorHandlerkEvent *pErrHandlerEvent =
(tEplErrorHandlerkEvent *) pEvent_p->m_pArg;
ulDllErrorEvents = pErrHandlerEvent->m_ulDllErrorEvents;
// check the several error events
if ((EplErrorHandlerkInstance_g.m_CnLossSoc.
m_dwThreshold > 0)
&& ((ulDllErrorEvents & EPL_DLL_ERR_CN_LOSS_SOC) != 0)) { // loss of SoC event occured
// increment cumulative counter by 1
EplErrorHandlerkInstance_g.m_CnLossSoc.
m_dwCumulativeCnt++;
// increment threshold counter by 8
EplErrorHandlerkInstance_g.m_CnLossSoc.
m_dwThresholdCnt += 8;
if (EplErrorHandlerkInstance_g.m_CnLossSoc.m_dwThresholdCnt >= EplErrorHandlerkInstance_g.m_CnLossSoc.m_dwThreshold) { // threshold is reached
// $$$ d.k.: generate error history entry E_DLL_LOSS_SOC_TH
// post event to NMT state machine
NmtEvent = kEplNmtEventNmtCycleError;
Event.m_EventSink = kEplEventSinkNmtk;
Event.m_EventType =
kEplEventTypeNmtEvent;
Event.m_pArg = &NmtEvent;
Event.m_uiSize = sizeof(NmtEvent);
Ret = EplEventkPost(&Event);
}
EplErrorHandlerkInstance_g.m_ulDllErrorEvents |=
EPL_DLL_ERR_CN_LOSS_SOC;
}
if ((EplErrorHandlerkInstance_g.m_CnLossPreq.
m_dwThreshold > 0)
&& ((ulDllErrorEvents & EPL_DLL_ERR_CN_LOSS_PREQ) != 0)) { // loss of PReq event occured
// increment cumulative counter by 1
EplErrorHandlerkInstance_g.m_CnLossPreq.
m_dwCumulativeCnt++;
// increment threshold counter by 8
EplErrorHandlerkInstance_g.m_CnLossPreq.
m_dwThresholdCnt += 8;
if (EplErrorHandlerkInstance_g.m_CnLossPreq.m_dwThresholdCnt >= EplErrorHandlerkInstance_g.m_CnLossPreq.m_dwThreshold) { // threshold is reached
// $$$ d.k.: generate error history entry E_DLL_LOSS_PREQ_TH
// post event to NMT state machine
NmtEvent = kEplNmtEventNmtCycleError;
Event.m_EventSink = kEplEventSinkNmtk;
Event.m_EventType =
kEplEventTypeNmtEvent;
Event.m_pArg = &NmtEvent;
Event.m_uiSize = sizeof(NmtEvent);
Ret = EplEventkPost(&Event);
}
}
if ((EplErrorHandlerkInstance_g.m_CnLossPreq.
m_dwThresholdCnt > 0)
&& ((ulDllErrorEvents & EPL_DLL_ERR_CN_RECVD_PREQ) != 0)) { // PReq correctly received
// decrement threshold counter by 1
EplErrorHandlerkInstance_g.m_CnLossPreq.
m_dwThresholdCnt--;
}
if ((EplErrorHandlerkInstance_g.m_CnCrcErr.
m_dwThreshold > 0)
&& ((ulDllErrorEvents & EPL_DLL_ERR_CN_CRC) != 0)) { // CRC error event occured
// increment cumulative counter by 1
EplErrorHandlerkInstance_g.m_CnCrcErr.
m_dwCumulativeCnt++;
// increment threshold counter by 8
EplErrorHandlerkInstance_g.m_CnCrcErr.
m_dwThresholdCnt += 8;
if (EplErrorHandlerkInstance_g.m_CnCrcErr.m_dwThresholdCnt >= EplErrorHandlerkInstance_g.m_CnCrcErr.m_dwThreshold) { // threshold is reached
// $$$ d.k.: generate error history entry E_DLL_CRC_TH
// post event to NMT state machine
NmtEvent = kEplNmtEventNmtCycleError;
Event.m_EventSink = kEplEventSinkNmtk;
Event.m_EventType =
kEplEventTypeNmtEvent;
Event.m_pArg = &NmtEvent;
Event.m_uiSize = sizeof(NmtEvent);
Ret = EplEventkPost(&Event);
}
EplErrorHandlerkInstance_g.m_ulDllErrorEvents |=
EPL_DLL_ERR_CN_CRC;
}
if ((ulDllErrorEvents & EPL_DLL_ERR_INVALID_FORMAT) != 0) { // invalid format error occured (only direct reaction)
// $$$ d.k.: generate error history entry E_DLL_INVALID_FORMAT
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
if (pErrHandlerEvent->m_NmtState >= kEplNmtMsNotActive) { // MN is active
if (pErrHandlerEvent->m_uiNodeId != 0) {
tEplHeartbeatEvent
HeartbeatEvent;
// remove node from isochronous phase
Ret =
EplDllkDeleteNode
(pErrHandlerEvent->
m_uiNodeId);
// inform NmtMnu module about state change, which shall send NMT command ResetNode to this CN
HeartbeatEvent.m_uiNodeId =
pErrHandlerEvent->
m_uiNodeId;
HeartbeatEvent.m_NmtState =
kEplNmtCsNotActive;
HeartbeatEvent.m_wErrorCode =
EPL_E_DLL_INVALID_FORMAT;
Event.m_EventSink =
kEplEventSinkNmtMnu;
Event.m_EventType =
kEplEventTypeHeartbeat;
Event.m_uiSize =
sizeof(HeartbeatEvent);
Event.m_pArg = &HeartbeatEvent;
Ret = EplEventkPost(&Event);
}
// $$$ and else should lead to InternComError
} else
#endif
{ // CN is active
// post event to NMT state machine
NmtEvent = kEplNmtEventInternComError;
Event.m_EventSink = kEplEventSinkNmtk;
Event.m_EventType =
kEplEventTypeNmtEvent;
Event.m_pArg = &NmtEvent;
Event.m_uiSize = sizeof(NmtEvent);
Ret = EplEventkPost(&Event);
}
}
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
if ((EplErrorHandlerkInstance_g.m_MnCrcErr.
m_dwThreshold > 0)
&& ((ulDllErrorEvents & EPL_DLL_ERR_MN_CRC) != 0)) { // CRC error event occured
// increment cumulative counter by 1
EplErrorHandlerkInstance_g.m_MnCrcErr.
m_dwCumulativeCnt++;
// increment threshold counter by 8
EplErrorHandlerkInstance_g.m_MnCrcErr.
m_dwThresholdCnt += 8;
if (EplErrorHandlerkInstance_g.m_MnCrcErr.m_dwThresholdCnt >= EplErrorHandlerkInstance_g.m_MnCrcErr.m_dwThreshold) { // threshold is reached
// $$$ d.k.: generate error history entry E_DLL_CRC_TH
// post event to NMT state machine
NmtEvent = kEplNmtEventNmtCycleError;
Event.m_EventSink = kEplEventSinkNmtk;
Event.m_EventType =
kEplEventTypeNmtEvent;
Event.m_pArg = &NmtEvent;
Event.m_uiSize = sizeof(NmtEvent);
Ret = EplEventkPost(&Event);
}
EplErrorHandlerkInstance_g.m_ulDllErrorEvents |=
EPL_DLL_ERR_MN_CRC;
}
if ((EplErrorHandlerkInstance_g.m_MnCycTimeExceed.
m_dwThreshold > 0)
&& ((ulDllErrorEvents & EPL_DLL_ERR_MN_CYCTIMEEXCEED) != 0)) { // cycle time exceeded event occured
// increment cumulative counter by 1
EplErrorHandlerkInstance_g.m_MnCycTimeExceed.
m_dwCumulativeCnt++;
// increment threshold counter by 8
EplErrorHandlerkInstance_g.m_MnCycTimeExceed.
m_dwThresholdCnt += 8;
if (EplErrorHandlerkInstance_g.m_MnCycTimeExceed.m_dwThresholdCnt >= EplErrorHandlerkInstance_g.m_MnCycTimeExceed.m_dwThreshold) { // threshold is reached
// $$$ d.k.: generate error history entry E_DLL_CYCLE_EXCEED_TH
// post event to NMT state machine
NmtEvent = kEplNmtEventNmtCycleError;
Event.m_EventSink = kEplEventSinkNmtk;
Event.m_EventType =
kEplEventTypeNmtEvent;
Event.m_pArg = &NmtEvent;
Event.m_uiSize = sizeof(NmtEvent);
Ret = EplEventkPost(&Event);
}
// $$$ d.k.: else generate error history entry E_DLL_CYCLE_EXCEED
EplErrorHandlerkInstance_g.m_ulDllErrorEvents |=
EPL_DLL_ERR_MN_CYCTIMEEXCEED;
}
if ((ulDllErrorEvents & EPL_DLL_ERR_MN_CN_LOSS_PRES) != 0) { // CN loss PRes event occured
unsigned int uiNodeId;
uiNodeId = pErrHandlerEvent->m_uiNodeId - 1;
if ((uiNodeId <
tabentries(EplErrorHandlerkInstance_g.
m_adwMnCnLossPresCumCnt))
&& (EplErrorHandlerkInstance_g.
m_adwMnCnLossPresThreshold[uiNodeId] >
0)) {
// increment cumulative counter by 1
EplErrorHandlerkInstance_g.
m_adwMnCnLossPresCumCnt[uiNodeId]++;
// increment threshold counter by 8
EplErrorHandlerkInstance_g.
m_adwMnCnLossPresThrCnt[uiNodeId] +=
8;
if (EplErrorHandlerkInstance_g.
m_adwMnCnLossPresThrCnt[uiNodeId]
>= EplErrorHandlerkInstance_g.m_adwMnCnLossPresThreshold[uiNodeId]) { // threshold is reached
tEplHeartbeatEvent
HeartbeatEvent;
// $$$ d.k.: generate error history entry E_DLL_LOSS_PRES_TH
// remove node from isochronous phase
Ret =
EplDllkDeleteNode
(pErrHandlerEvent->
m_uiNodeId);
// inform NmtMnu module about state change, which shall send NMT command ResetNode to this CN
HeartbeatEvent.m_uiNodeId =
pErrHandlerEvent->
m_uiNodeId;
HeartbeatEvent.m_NmtState =
kEplNmtCsNotActive;
HeartbeatEvent.m_wErrorCode =
EPL_E_DLL_LOSS_PRES_TH;
Event.m_EventSink =
kEplEventSinkNmtMnu;
Event.m_EventType =
kEplEventTypeHeartbeat;
Event.m_uiSize =
sizeof(HeartbeatEvent);
Event.m_pArg = &HeartbeatEvent;
Ret = EplEventkPost(&Event);
}
EplErrorHandlerkInstance_g.
m_afMnCnLossPresEvent[uiNodeId] =
TRUE;
}
}
#endif
break;
}
// NMT event
case kEplEventTypeNmtEvent:
{
if ((*(tEplNmtEvent *) pEvent_p->m_pArg) == kEplNmtEventDllCeSoa) { // SoA event of CN -> decrement threshold counters
if ((EplErrorHandlerkInstance_g.m_ulDllErrorEvents & EPL_DLL_ERR_CN_LOSS_SOC) == 0) { // decrement loss of SoC threshold counter, because it didn't occur last cycle
if (EplErrorHandlerkInstance_g.
m_CnLossSoc.m_dwThresholdCnt > 0) {
EplErrorHandlerkInstance_g.
m_CnLossSoc.
m_dwThresholdCnt--;
}
}
if ((EplErrorHandlerkInstance_g.m_ulDllErrorEvents & EPL_DLL_ERR_CN_CRC) == 0) { // decrement CRC threshold counter, because it didn't occur last cycle
if (EplErrorHandlerkInstance_g.
m_CnCrcErr.m_dwThresholdCnt > 0) {
EplErrorHandlerkInstance_g.
m_CnCrcErr.
m_dwThresholdCnt--;
}
}
}
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
else if ((*(tEplNmtEvent *) pEvent_p->m_pArg) == kEplNmtEventDllMeSoaSent) { // SoA event of MN -> decrement threshold counters
tEplDllkNodeInfo *pIntNodeInfo;
unsigned int uiNodeId;
Ret = EplDllkGetFirstNodeInfo(&pIntNodeInfo);
if (Ret != kEplSuccessful) {
break;
}
// iterate through node info structure list
while (pIntNodeInfo != NULL) {
uiNodeId = pIntNodeInfo->m_uiNodeId - 1;
if (uiNodeId <
tabentries
(EplErrorHandlerkInstance_g.
m_adwMnCnLossPresCumCnt)) {
if (EplErrorHandlerkInstance_g.
m_afMnCnLossPresEvent
[uiNodeId] == FALSE) {
if (EplErrorHandlerkInstance_g.m_adwMnCnLossPresThrCnt[uiNodeId] > 0) {
EplErrorHandlerkInstance_g.
m_adwMnCnLossPresThrCnt
[uiNodeId]--;
}
} else {
EplErrorHandlerkInstance_g.
m_afMnCnLossPresEvent
[uiNodeId] = FALSE;
}
}
pIntNodeInfo =
pIntNodeInfo->m_pNextNodeInfo;
}
if ((EplErrorHandlerkInstance_g.m_ulDllErrorEvents & EPL_DLL_ERR_MN_CRC) == 0) { // decrement CRC threshold counter, because it didn't occur last cycle
if (EplErrorHandlerkInstance_g.
m_MnCrcErr.m_dwThresholdCnt > 0) {
EplErrorHandlerkInstance_g.
m_MnCrcErr.
m_dwThresholdCnt--;
}
}
if ((EplErrorHandlerkInstance_g.m_ulDllErrorEvents & EPL_DLL_ERR_MN_CYCTIMEEXCEED) == 0) { // decrement cycle exceed threshold counter, because it didn't occur last cycle
if (EplErrorHandlerkInstance_g.
m_MnCycTimeExceed.m_dwThresholdCnt >
0) {
EplErrorHandlerkInstance_g.
m_MnCycTimeExceed.
m_dwThresholdCnt--;
}
}
}
#endif
// reset error events
EplErrorHandlerkInstance_g.m_ulDllErrorEvents = 0L;
break;
}
// unknown type
default:
{
}
} // end of switch(pEvent_p->m_EventType)
return Ret;
}
//=========================================================================//
// //
// P R I V A T E F U N C T I O N S //
// //
//=========================================================================//
//---------------------------------------------------------------------------
//
// Function: EplErrorHandlerkLinkErrorCounter
//
// Description: link specified error counter structure to OD entry
//
// Parameters: pErrorCounter_p = pointer to error counter structure
// uiIndex_p = OD index
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
static tEplKernel EplErrorHandlerkLinkErrorCounter(tEplErrorHandlerkErrorCounter
* pErrorCounter_p,
unsigned int uiIndex_p)
{
tEplKernel Ret = kEplSuccessful;
tEplVarParam VarParam;
VarParam.m_pData = &pErrorCounter_p->m_dwCumulativeCnt;
VarParam.m_Size = sizeof(u32);
VarParam.m_uiIndex = uiIndex_p;
VarParam.m_uiSubindex = 0x01;
VarParam.m_ValidFlag = kVarValidAll;
Ret = EplObdDefineVar(&VarParam);
if (Ret != kEplSuccessful) {
goto Exit;
}
VarParam.m_pData = &pErrorCounter_p->m_dwThresholdCnt;
VarParam.m_Size = sizeof(u32);
VarParam.m_uiIndex = uiIndex_p;
VarParam.m_uiSubindex = 0x02;
VarParam.m_ValidFlag = kVarValidAll;
Ret = EplObdDefineVar(&VarParam);
if (Ret != kEplSuccessful) {
goto Exit;
}
VarParam.m_pData = &pErrorCounter_p->m_dwThreshold;
VarParam.m_Size = sizeof(u32);
VarParam.m_uiIndex = uiIndex_p;
VarParam.m_uiSubindex = 0x03;
VarParam.m_ValidFlag = kVarValidAll;
Ret = EplObdDefineVar(&VarParam);
if (Ret != kEplSuccessful) {
goto Exit;
}
Exit:
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplErrorHandlerkLinkErrorCounter
//
// Description: link specified error counter structure to OD entry
//
// Parameters: pErrorCounter_p = pointer to error counter structure
// uiIndex_p = OD index
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
static tEplKernel EplErrorHandlerkLinkArray(u32 * pdwValue_p,
unsigned int uiValueCount_p,
unsigned int uiIndex_p)
{
tEplKernel Ret = kEplSuccessful;
tEplVarParam VarParam;
tEplObdSize EntrySize;
u8 bIndexEntries;
EntrySize = (tEplObdSize) sizeof(bIndexEntries);
Ret = EplObdReadEntry(uiIndex_p,
0x00, (void *)&bIndexEntries, &EntrySize);
if ((Ret != kEplSuccessful) || (bIndexEntries == 0x00)) {
// Object doesn't exist or invalid entry number
Ret = kEplObdIndexNotExist;
goto Exit;
}
if (bIndexEntries < uiValueCount_p) {
uiValueCount_p = bIndexEntries;
}
VarParam.m_Size = sizeof(u32);
VarParam.m_uiIndex = uiIndex_p;
VarParam.m_ValidFlag = kVarValidAll;
for (VarParam.m_uiSubindex = 0x01;
VarParam.m_uiSubindex <= uiValueCount_p; VarParam.m_uiSubindex++) {
VarParam.m_pData = pdwValue_p;
Ret = EplObdDefineVar(&VarParam);
if (Ret != kEplSuccessful) {
goto Exit;
}
pdwValue_p++;
}
Exit:
return Ret;
}
#endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
#endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
// EOF
