Google Git
Sign in
android-kvm / linux / 9d7164cfdb611c2f864d535ae5794f23db3d84f7 / . / drivers / staging / epl / EplDllk.c
blob: dee0d3dc2f3326695b196df2fa2317ae37da79b2 [file] [log] [blame]
/****************************************************************************
(c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29
www.systec-electronic.com
Project: openPOWERLINK
Description: source file for kernel DLL 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: EplDllk.c,v $
$Author: D.Krueger $
$Revision: 1.21 $ $Date: 2008/11/13 17:13:09 $
$State: Exp $
Build Environment:
GCC V3.4
-------------------------------------------------------------------------
Revision History:
2006/06/12 d.k.: start of the implementation, version 1.00
****************************************************************************/
#include "kernel/EplDllk.h"
#include "kernel/EplDllkCal.h"
#include "kernel/EplEventk.h"
#include "kernel/EplNmtk.h"
#include "edrv.h"
#include "Benchmark.h"
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
#include "kernel/EplPdok.h"
#endif
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_VETH)) != 0)
#include "kernel/VirtualEthernet.h"
#endif
//#if EPL_TIMER_USE_HIGHRES != FALSE
#include "kernel/EplTimerHighResk.h"
//#endif
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) == 0)
#error "EPL module DLLK needs EPL module NMTK!"
#endif
#if (EPL_DLL_PRES_READY_AFTER_SOA != FALSE) && (EPL_DLL_PRES_READY_AFTER_SOC != FALSE)
#error "EPL module DLLK: select only one of EPL_DLL_PRES_READY_AFTER_SOA and EPL_DLL_PRES_READY_AFTER_SOC."
#endif
#if ((EPL_DLL_PRES_READY_AFTER_SOA != FALSE) || (EPL_DLL_PRES_READY_AFTER_SOC != FALSE)) \
&& (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) == 0)
#error "EPL module DLLK: currently, EPL_DLL_PRES_READY_AFTER_* is not supported if EPL_MODULE_NMT_MN is enabled."
#endif
#if (EDRV_FAST_TXFRAMES == FALSE) && \
((EPL_DLL_PRES_READY_AFTER_SOA != FALSE) || (EPL_DLL_PRES_READY_AFTER_SOC != FALSE))
#error "EPL module DLLK: EPL_DLL_PRES_READY_AFTER_* is enabled, but not EDRV_FAST_TXFRAMES."
#endif
/***************************************************************************/
/* */
/* */
/* G L O B A L D E F I N I T I O N S */
/* */
/* */
/***************************************************************************/
//---------------------------------------------------------------------------
// const defines
//---------------------------------------------------------------------------
// TracePoint support for realtime-debugging
#ifdef _DBG_TRACE_POINTS_
void PUBLIC TgtDbgSignalTracePoint (BYTE bTracePointNumber_p);
void PUBLIC TgtDbgPostTraceValue (DWORD dwTraceValue_p);
#define TGT_DBG_SIGNAL_TRACE_POINT(p) TgtDbgSignalTracePoint(p)
#define TGT_DBG_POST_TRACE_VALUE(v) TgtDbgPostTraceValue(v)
#else
#define TGT_DBG_SIGNAL_TRACE_POINT(p)
#define TGT_DBG_POST_TRACE_VALUE(v)
#endif
#define EPL_DLLK_DBG_POST_TRACE_VALUE(Event_p, uiNodeId_p, wErrorCode_p) \
TGT_DBG_POST_TRACE_VALUE((kEplEventSinkDllk << 28) | (Event_p << 24) \
| (uiNodeId_p << 16) | wErrorCode_p)
/***************************************************************************/
/* */
/* */
/* C L A S S EplDllk */
/* */
/* */
/***************************************************************************/
//
// Description:
//
//
/***************************************************************************/
//=========================================================================//
// //
// P R I V A T E D E F I N I T I O N S //
// //
//=========================================================================//
//---------------------------------------------------------------------------
// const defines
//---------------------------------------------------------------------------
// defines for indexes of tEplDllInstance.m_pTxFrameInfo
#define EPL_DLLK_TXFRAME_IDENTRES 0 // IdentResponse on CN / MN
#define EPL_DLLK_TXFRAME_STATUSRES 1 // StatusResponse on CN / MN
#define EPL_DLLK_TXFRAME_NMTREQ 2 // NMT Request from FIFO on CN / MN
#define EPL_DLLK_TXFRAME_NONEPL 3 // non-EPL frame from FIFO on CN / MN
#define EPL_DLLK_TXFRAME_PRES 4 // PRes on CN / MN
#define EPL_DLLK_TXFRAME_SOC 5 // SoC on MN
#define EPL_DLLK_TXFRAME_SOA 6 // SoA on MN
#define EPL_DLLK_TXFRAME_PREQ 7 // PReq on MN
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
#define EPL_DLLK_TXFRAME_COUNT (7 + EPL_D_NMT_MaxCNNumber_U8 + 2) // on MN: 7 + MaxPReq of regular CNs + 1 Diag + 1 Router
#else
#define EPL_DLLK_TXFRAME_COUNT 5 // on CN: 5
#endif
#define EPL_DLLK_BUFLEN_EMPTY 0 // buffer is empty
#define EPL_DLLK_BUFLEN_FILLING 1 // just the buffer is being filled
#define EPL_DLLK_BUFLEN_MIN 60 // minimum ethernet frame length
//---------------------------------------------------------------------------
// local types
//---------------------------------------------------------------------------
typedef enum
{
kEplDllGsInit = 0x00, // MN/CN: initialisation (< PreOp2)
kEplDllCsWaitPreq = 0x01, // CN: wait for PReq frame
kEplDllCsWaitSoc = 0x02, // CN: wait for SoC frame
kEplDllCsWaitSoa = 0x03, // CN: wait for SoA frame
kEplDllMsNonCyclic = 0x04, // MN: reduced EPL cycle (PreOp1)
kEplDllMsWaitSocTrig = 0x05, // MN: wait for SoC trigger (cycle timer)
kEplDllMsWaitPreqTrig = 0x06, // MN: wait for (first) PReq trigger (WaitSoCPReq_U32)
kEplDllMsWaitPres = 0x07, // MN: wait for PRes frame from CN
kEplDllMsWaitSoaTrig = 0x08, // MN: wait for SoA trigger (PRes transmitted)
kEplDllMsWaitAsndTrig = 0x09, // MN: wait for ASnd trigger (SoA transmitted)
kEplDllMsWaitAsnd = 0x0A, // MN: wait for ASnd frame if SoA contained invitation
} tEplDllState;
typedef struct
{
BYTE m_be_abSrcMac[6];
tEdrvTxBuffer* m_pTxBuffer; // Buffers for Tx-Frames
unsigned int m_uiMaxTxFrames;
BYTE m_bFlag1; // Flag 1 with EN, EC for PRes, StatusRes
BYTE m_bMnFlag1; // Flag 1 with EA, ER from PReq, SoA of MN
BYTE m_bFlag2; // Flag 2 with PR and RS for PRes, StatusRes, IdentRes
tEplDllConfigParam m_DllConfigParam;
tEplDllIdentParam m_DllIdentParam;
tEplDllState m_DllState;
tEplDllkCbAsync m_pfnCbAsync;
tEplDllAsndFilter m_aAsndFilter[EPL_DLL_MAX_ASND_SERVICE_ID];
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
tEplDllkNodeInfo* m_pFirstNodeInfo;
tEplDllkNodeInfo* m_pCurNodeInfo;
tEplDllkNodeInfo m_aNodeInfo[EPL_NMT_MAX_NODE_ID];
tEplDllReqServiceId m_LastReqServiceId;
unsigned int m_uiLastTargetNodeId;
#endif
#if EPL_TIMER_USE_HIGHRES != FALSE
tEplTimerHdl m_TimerHdlCycle; // used for EPL cycle monitoring on CN and generation on MN
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
tEplTimerHdl m_TimerHdlResponse; // used for CN response monitoring
#endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
#endif
unsigned int m_uiCycleCount; // cycle counter (needed for multiplexed cycle support)
unsigned long long m_ullFrameTimeout; // frame timeout (cycle length + loss of frame tolerance)
} tEplDllkInstance;
//---------------------------------------------------------------------------
// local vars
//---------------------------------------------------------------------------
// if no dynamic memory allocation shall be used
// define structures statically
static tEplDllkInstance EplDllkInstance_g;
static tEdrvTxBuffer aEplDllkTxBuffer_l[EPL_DLLK_TXFRAME_COUNT];
//---------------------------------------------------------------------------
// local function prototypes
//---------------------------------------------------------------------------
// change DLL state on event
static tEplKernel EplDllkChangeState(tEplNmtEvent NmtEvent_p, tEplNmtState NmtState_p);
// called from EdrvInterruptHandler()
static void EplDllkCbFrameReceived(tEdrvRxBuffer * pRxBuffer_p);
// called from EdrvInterruptHandler()
static void EplDllkCbFrameTransmitted(tEdrvTxBuffer * pTxBuffer_p);
// check frame and set missing information
static tEplKernel EplDllkCheckFrame(tEplFrame * pFrame_p, unsigned int uiFrameSize_p);
// called by high resolution timer module to monitor EPL cycle as CN
#if EPL_TIMER_USE_HIGHRES != FALSE
static tEplKernel PUBLIC EplDllkCbCnTimer(tEplTimerEventArg* pEventArg_p);
#endif
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
// MN: returns internal node info structure
static tEplDllkNodeInfo* EplDllkGetNodeInfo(unsigned int uiNodeId_p);
// transmit SoA
static tEplKernel EplDllkMnSendSoa(tEplNmtState NmtState_p,
tEplDllState* pDllStateProposed_p,
BOOL fEnableInvitation_p);
static tEplKernel EplDllkMnSendSoc(void);
static tEplKernel EplDllkMnSendPreq(tEplNmtState NmtState_p,
tEplDllState* pDllStateProposed_p);
static tEplKernel EplDllkAsyncFrameNotReceived(tEplDllReqServiceId ReqServiceId_p, unsigned int uiNodeId_p);
static tEplKernel PUBLIC EplDllkCbMnTimerCycle(tEplTimerEventArg* pEventArg_p);
static tEplKernel PUBLIC EplDllkCbMnTimerResponse(tEplTimerEventArg* pEventArg_p);
#endif
//=========================================================================//
// //
// P U B L I C F U N C T I O N S //
// //
//=========================================================================//
//---------------------------------------------------------------------------
//
// Function: EplDllkAddInstance()
//
// Description: add and initialize new instance of EPL stack
//
// Parameters: pInitParam_p = initialisation parameters like MAC address
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplDllkAddInstance(tEplDllkInitParam * pInitParam_p)
{
tEplKernel Ret = kEplSuccessful;
unsigned int uiIndex;
tEdrvInitParam EdrvInitParam;
// reset instance structure
EPL_MEMSET(&EplDllkInstance_g, 0, sizeof (EplDllkInstance_g));
#if EPL_TIMER_USE_HIGHRES != FALSE
Ret = EplTimerHighReskInit();
if (Ret != kEplSuccessful)
{ // error occured while initializing high resolution timer module
goto Exit;
}
#endif
// if dynamic memory allocation available
// allocate instance structure
// allocate TPDO and RPDO table with default size
// initialize and link pointers in instance structure to frame tables
EplDllkInstance_g.m_pTxBuffer = aEplDllkTxBuffer_l;
EplDllkInstance_g.m_uiMaxTxFrames = sizeof (aEplDllkTxBuffer_l) / sizeof (tEdrvTxBuffer);
// initialize state
EplDllkInstance_g.m_DllState = kEplDllGsInit;
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
// set up node info structure
for (uiIndex = 0; uiIndex < tabentries (EplDllkInstance_g.m_aNodeInfo); uiIndex++)
{
EplDllkInstance_g.m_aNodeInfo[uiIndex].m_uiNodeId = uiIndex + 1;
EplDllkInstance_g.m_aNodeInfo[uiIndex].m_wPresPayloadLimit = 0xFFFF;
}
#endif
// initialize Edrv
EPL_MEMCPY(EdrvInitParam.m_abMyMacAddr, pInitParam_p->m_be_abSrcMac, 6);
EdrvInitParam.m_pfnRxHandler = EplDllkCbFrameReceived;
EdrvInitParam.m_pfnTxHandler = EplDllkCbFrameTransmitted;
Ret = EdrvInit(&EdrvInitParam);
if (Ret != kEplSuccessful)
{ // error occured while initializing ethernet driver
goto Exit;
}
// copy local MAC address from Ethernet driver back to local instance structure
// because Ethernet driver may have read it from controller EEPROM
EPL_MEMCPY(EplDllkInstance_g.m_be_abSrcMac, EdrvInitParam.m_abMyMacAddr, 6);
EPL_MEMCPY(pInitParam_p->m_be_abSrcMac, EdrvInitParam.m_abMyMacAddr, 6);
// initialize TxBuffer array
for (uiIndex = 0; uiIndex < EplDllkInstance_g.m_uiMaxTxFrames; uiIndex++)
{
EplDllkInstance_g.m_pTxBuffer[uiIndex].m_pbBuffer = NULL;
}
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_VETH)) != 0)
Ret = VEthAddInstance(pInitParam_p);
#endif
Exit:
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkDelInstance()
//
// Description: deletes an instance of EPL stack
//
// Parameters: (none)
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplDllkDelInstance(void)
{
tEplKernel Ret = kEplSuccessful;
// reset state
EplDllkInstance_g.m_DllState = kEplDllGsInit;
#if EPL_TIMER_USE_HIGHRES != FALSE
Ret = EplTimerHighReskDelInstance();
#endif
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_VETH)) != 0)
Ret = VEthDelInstance();
#endif
Ret = EdrvShutdown();
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkCreateTxFrame
//
// Description: creates the buffer for a Tx frame and registers it to the
// ethernet driver
//
// Parameters: puiHandle_p = OUT: handle to frame buffer
// ppFrame_p = OUT: pointer to pointer of EPL frame
// puiFrameSize_p = IN/OUT: pointer to size of frame
// returned size is always equal or larger than
// requested size, if that is not possible
// an error will be returned
// MsgType_p = EPL message type
// ServiceId_p = Service ID in case of ASnd frame, otherwise
// kEplDllAsndNotDefined
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplDllkCreateTxFrame (unsigned int * puiHandle_p,
tEplFrame ** ppFrame_p,
unsigned int * puiFrameSize_p,
tEplMsgType MsgType_p,
tEplDllAsndServiceId ServiceId_p)
{
tEplKernel Ret = kEplSuccessful;
tEplFrame *pTxFrame;
unsigned int uiHandle = EplDllkInstance_g.m_uiMaxTxFrames;
tEdrvTxBuffer *pTxBuffer = NULL;
if (MsgType_p == kEplMsgTypeAsnd)
{
// search for fixed Tx buffers
if (ServiceId_p == kEplDllAsndIdentResponse)
{
uiHandle = EPL_DLLK_TXFRAME_IDENTRES;
}
else if (ServiceId_p == kEplDllAsndStatusResponse)
{
uiHandle = EPL_DLLK_TXFRAME_STATUSRES;
}
else if ((ServiceId_p == kEplDllAsndNmtRequest) || (ServiceId_p == kEplDllAsndNmtCommand))
{
uiHandle = EPL_DLLK_TXFRAME_NMTREQ;
}
if (uiHandle >= EplDllkInstance_g.m_uiMaxTxFrames)
{ // look for free entry
uiHandle = EPL_DLLK_TXFRAME_PREQ;
pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[uiHandle];
for (; uiHandle < EplDllkInstance_g.m_uiMaxTxFrames; uiHandle++, pTxBuffer++)
{
if (pTxBuffer->m_pbBuffer == NULL)
{ // free entry found
break;
}
}
}
}
else if (MsgType_p == kEplMsgTypeNonEpl)
{
uiHandle = EPL_DLLK_TXFRAME_NONEPL;
}
else if (MsgType_p == kEplMsgTypePres)
{
uiHandle = EPL_DLLK_TXFRAME_PRES;
}
else if (MsgType_p == kEplMsgTypeSoc)
{
uiHandle = EPL_DLLK_TXFRAME_SOC;
}
else if (MsgType_p == kEplMsgTypeSoa)
{
uiHandle = EPL_DLLK_TXFRAME_SOA;
}
else
{ // look for free entry
uiHandle = EPL_DLLK_TXFRAME_PREQ;
pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[uiHandle];
for (; uiHandle < EplDllkInstance_g.m_uiMaxTxFrames; uiHandle++, pTxBuffer++)
{
if (pTxBuffer->m_pbBuffer == NULL)
{ // free entry found
break;
}
}
if (pTxBuffer->m_pbBuffer != NULL)
{
Ret = kEplEdrvNoFreeBufEntry;
goto Exit;
}
}
// test if requested entry is free
pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[uiHandle];
if (pTxBuffer->m_pbBuffer != NULL)
{ // entry is not free
Ret = kEplEdrvNoFreeBufEntry;
goto Exit;
}
// setup Tx buffer
pTxBuffer->m_EplMsgType = MsgType_p;
pTxBuffer->m_uiMaxBufferLen = *puiFrameSize_p;
Ret = EdrvAllocTxMsgBuffer(pTxBuffer);
if (Ret != kEplSuccessful)
{ // error occured while registering Tx frame
goto Exit;
}
// because buffer size may be larger than requested
// memorize real length of frame
pTxBuffer->m_uiTxMsgLen = *puiFrameSize_p;
// fill whole frame with 0
EPL_MEMSET(pTxBuffer->m_pbBuffer, 0, pTxBuffer->m_uiMaxBufferLen);
pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
if (MsgType_p != kEplMsgTypeNonEpl)
{ // fill out Frame only if it is an EPL frame
// ethertype
AmiSetWordToBe(&pTxFrame->m_be_wEtherType, EPL_C_DLL_ETHERTYPE_EPL);
// source node ID
AmiSetByteToLe(&pTxFrame->m_le_bSrcNodeId, (BYTE) EplDllkInstance_g.m_DllConfigParam.m_uiNodeId);
// source MAC address
EPL_MEMCPY(&pTxFrame->m_be_abSrcMac[0], &EplDllkInstance_g.m_be_abSrcMac[0], 6);
switch (MsgType_p)
{
case kEplMsgTypeAsnd:
// destination MAC address
AmiSetQword48ToBe(&pTxFrame->m_be_abDstMac[0], EPL_C_DLL_MULTICAST_ASND);
// destination node ID
switch (ServiceId_p)
{
case kEplDllAsndIdentResponse:
case kEplDllAsndStatusResponse:
{ // IdentResponses and StatusResponses are Broadcast
AmiSetByteToLe(&pTxFrame->m_le_bDstNodeId, (BYTE) EPL_C_ADR_BROADCAST);
break;
}
default:
break;
}
// ASnd Service ID
AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.m_le_bServiceId, ServiceId_p);
break;
case kEplMsgTypeSoc:
// destination MAC address
AmiSetQword48ToBe(&pTxFrame->m_be_abDstMac[0], EPL_C_DLL_MULTICAST_SOC);
// destination node ID
AmiSetByteToLe(&pTxFrame->m_le_bDstNodeId, (BYTE) EPL_C_ADR_BROADCAST);
// reset Flags
//AmiSetByteToLe(&pTxFrame->m_Data.m_Soc.m_le_bFlag1, (BYTE) 0);
//AmiSetByteToLe(&pTxFrame->m_Data.m_Soc.m_le_bFlag2, (BYTE) 0);
break;
case kEplMsgTypeSoa:
// destination MAC address
AmiSetQword48ToBe(&pTxFrame->m_be_abDstMac[0], EPL_C_DLL_MULTICAST_SOA);
// destination node ID
AmiSetByteToLe(&pTxFrame->m_le_bDstNodeId, (BYTE) EPL_C_ADR_BROADCAST);
// reset Flags
//AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.m_le_bFlag1, (BYTE) 0);
//AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.m_le_bFlag2, (BYTE) 0);
// EPL profile version
AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.m_le_bEplVersion, (BYTE) EPL_SPEC_VERSION);
break;
case kEplMsgTypePres:
// destination MAC address
AmiSetQword48ToBe(&pTxFrame->m_be_abDstMac[0], EPL_C_DLL_MULTICAST_PRES);
// destination node ID
AmiSetByteToLe(&pTxFrame->m_le_bDstNodeId, (BYTE) EPL_C_ADR_BROADCAST);
// reset Flags
//AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bFlag1, (BYTE) 0);
//AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bFlag2, (BYTE) 0);
// PDO size
//AmiSetWordToLe(&pTxFrame->m_Data.m_Pres.m_le_wSize, 0);
break;
case kEplMsgTypePreq:
// reset Flags
//AmiSetByteToLe(&pTxFrame->m_Data.m_Preq.m_le_bFlag1, (BYTE) 0);
//AmiSetByteToLe(&pTxFrame->m_Data.m_Preq.m_le_bFlag2, (BYTE) 0);
// PDO size
//AmiSetWordToLe(&pTxFrame->m_Data.m_Preq.m_le_wSize, 0);
break;
default:
break;
}
// EPL message type
AmiSetByteToLe(&pTxFrame->m_le_bMessageType, (BYTE) MsgType_p);
}
*ppFrame_p = pTxFrame;
*puiFrameSize_p = pTxBuffer->m_uiMaxBufferLen;
*puiHandle_p = uiHandle;
Exit:
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkDeleteTxFrame
//
// Description: deletes the buffer for a Tx frame and frees it in the
// ethernet driver
//
// Parameters: uiHandle_p = IN: handle to frame buffer
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplDllkDeleteTxFrame (unsigned int uiHandle_p)
{
tEplKernel Ret = kEplSuccessful;
tEdrvTxBuffer *pTxBuffer = NULL;
if (uiHandle_p >= EplDllkInstance_g.m_uiMaxTxFrames)
{ // handle is not valid
Ret = kEplDllIllegalHdl;
goto Exit;
}
pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[uiHandle_p];
// mark buffer as free so that frame will not be send in future anymore
// $$$ d.k. What's up with running transmissions?
pTxBuffer->m_uiTxMsgLen = EPL_DLLK_BUFLEN_EMPTY;
pTxBuffer->m_pbBuffer = NULL;
// delete Tx buffer
Ret = EdrvReleaseTxMsgBuffer(pTxBuffer);
if (Ret != kEplSuccessful)
{ // error occured while releasing Tx frame
goto Exit;
}
Exit:
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkProcess
//
// Description: process the passed event
//
// Parameters: pEvent_p = event to be processed
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplDllkProcess(tEplEvent * pEvent_p)
{
tEplKernel Ret = kEplSuccessful;
tEplFrame *pTxFrame;
tEdrvTxBuffer *pTxBuffer;
unsigned int uiHandle;
unsigned int uiFrameSize;
BYTE abMulticastMac[6];
tEplDllAsyncReqPriority AsyncReqPriority;
unsigned int uiFrameCount;
tEplNmtState NmtState;
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
tEplFrameInfo FrameInfo;
#endif
switch (pEvent_p->m_EventType)
{
case kEplEventTypeDllkCreate:
{
// $$$ reset ethernet driver
NmtState = *((tEplNmtState*)pEvent_p->m_pArg);
// initialize flags for PRes and StatusRes
EplDllkInstance_g.m_bFlag1 = EPL_FRAME_FLAG1_EC;
EplDllkInstance_g.m_bMnFlag1 = 0;
EplDllkInstance_g.m_bFlag2 = 0;
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
// initialize linked node list
EplDllkInstance_g.m_pFirstNodeInfo = NULL;
#endif
// register TxFrames in Edrv
// IdentResponse
uiFrameSize = EPL_C_DLL_MINSIZE_IDENTRES;
Ret = EplDllkCreateTxFrame(&uiHandle, &pTxFrame, &uiFrameSize, kEplMsgTypeAsnd, kEplDllAsndIdentResponse);
if (Ret != kEplSuccessful)
{ // error occured while registering Tx frame
goto Exit;
}
// EPL profile version
AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_bEplProfileVersion,
(BYTE) EPL_SPEC_VERSION);
// FeatureFlags
AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_dwFeatureFlags,
EplDllkInstance_g.m_DllConfigParam.m_dwFeatureFlags);
// MTU
AmiSetWordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_wMtu,
(WORD) EplDllkInstance_g.m_DllConfigParam.m_uiAsyncMtu);
// PollInSize
AmiSetWordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_wPollInSize,
(WORD)EplDllkInstance_g.m_DllConfigParam.m_uiPreqActPayloadLimit);
// PollOutSize
AmiSetWordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_wPollOutSize,
(WORD)EplDllkInstance_g.m_DllConfigParam.m_uiPresActPayloadLimit);
// ResponseTime / PresMaxLatency
AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_dwResponseTime,
EplDllkInstance_g.m_DllConfigParam.m_dwPresMaxLatency);
// DeviceType
AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_dwDeviceType,
EplDllkInstance_g.m_DllIdentParam.m_dwDeviceType);
// VendorId
AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_dwVendorId,
EplDllkInstance_g.m_DllIdentParam.m_dwVendorId);
// ProductCode
AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_dwProductCode,
EplDllkInstance_g.m_DllIdentParam.m_dwProductCode);
// RevisionNumber
AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_dwRevisionNumber,
EplDllkInstance_g.m_DllIdentParam.m_dwRevisionNumber);
// SerialNumber
AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_dwSerialNumber,
EplDllkInstance_g.m_DllIdentParam.m_dwSerialNumber);
// VendorSpecificExt1
AmiSetQword64ToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_qwVendorSpecificExt1,
EplDllkInstance_g.m_DllIdentParam.m_qwVendorSpecificExt1);
// VerifyConfigurationDate
AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_dwVerifyConfigurationDate,
EplDllkInstance_g.m_DllIdentParam.m_dwVerifyConfigurationDate);
// VerifyConfigurationTime
AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_dwVerifyConfigurationTime,
EplDllkInstance_g.m_DllIdentParam.m_dwVerifyConfigurationTime);
// ApplicationSwDate
AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_dwApplicationSwDate,
EplDllkInstance_g.m_DllIdentParam.m_dwApplicationSwDate);
// ApplicationSwTime
AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_dwApplicationSwTime,
EplDllkInstance_g.m_DllIdentParam.m_dwApplicationSwTime);
// IPAddress
AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_dwIpAddress,
EplDllkInstance_g.m_DllIdentParam.m_dwIpAddress);
// SubnetMask
AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_dwSubnetMask,
EplDllkInstance_g.m_DllIdentParam.m_dwSubnetMask);
// DefaultGateway
AmiSetDwordToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_dwDefaultGateway,
EplDllkInstance_g.m_DllIdentParam.m_dwDefaultGateway);
// HostName
EPL_MEMCPY(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_sHostname[0],
&EplDllkInstance_g.m_DllIdentParam.m_sHostname[0],
sizeof (EplDllkInstance_g.m_DllIdentParam.m_sHostname));
// VendorSpecificExt2
EPL_MEMCPY(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_abVendorSpecificExt2[0],
&EplDllkInstance_g.m_DllIdentParam.m_abVendorSpecificExt2[0],
sizeof (EplDllkInstance_g.m_DllIdentParam.m_abVendorSpecificExt2));
// StatusResponse
uiFrameSize = EPL_C_DLL_MINSIZE_STATUSRES;
Ret = EplDllkCreateTxFrame(&uiHandle, &pTxFrame, &uiFrameSize, kEplMsgTypeAsnd, kEplDllAsndStatusResponse);
if (Ret != kEplSuccessful)
{ // error occured while registering Tx frame
goto Exit;
}
// PRes $$$ maybe move this to PDO module
if ((EplDllkInstance_g.m_DllConfigParam.m_fAsyncOnly == FALSE)
&& (EplDllkInstance_g.m_DllConfigParam.m_uiPresActPayloadLimit >= 36))
{ // it is not configured as async-only CN,
// so take part in isochronous phase and register PRes frame
uiFrameSize = EplDllkInstance_g.m_DllConfigParam.m_uiPresActPayloadLimit + 24;
Ret = EplDllkCreateTxFrame(&uiHandle, &pTxFrame, &uiFrameSize, kEplMsgTypePres, kEplDllAsndNotDefined);
if (Ret != kEplSuccessful)
{ // error occured while registering Tx frame
goto Exit;
}
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
// initially encode TPDO -> inform PDO module
FrameInfo.m_pFrame = pTxFrame;
FrameInfo.m_uiFrameSize = uiFrameSize;
Ret = EplPdokCbPdoTransmitted(&FrameInfo);
#endif
// reset cycle counter
EplDllkInstance_g.m_uiCycleCount = 0;
}
else
{ // it is an async-only CN
// fool EplDllkChangeState() to think that PRes was not expected
EplDllkInstance_g.m_uiCycleCount = 1;
}
// NMT request
uiFrameSize = EPL_C_IP_MAX_MTU;
Ret = EplDllkCreateTxFrame(&uiHandle, &pTxFrame, &uiFrameSize, kEplMsgTypeAsnd, kEplDllAsndNmtRequest);
if (Ret != kEplSuccessful)
{ // error occured while registering Tx frame
goto Exit;
}
// mark Tx buffer as empty
EplDllkInstance_g.m_pTxBuffer[uiHandle].m_uiTxMsgLen = EPL_DLLK_BUFLEN_EMPTY;
// non-EPL frame
uiFrameSize = EPL_C_IP_MAX_MTU;
Ret = EplDllkCreateTxFrame(&uiHandle, &pTxFrame, &uiFrameSize, kEplMsgTypeNonEpl, kEplDllAsndNotDefined);
if (Ret != kEplSuccessful)
{ // error occured while registering Tx frame
goto Exit;
}
// mark Tx buffer as empty
EplDllkInstance_g.m_pTxBuffer[uiHandle].m_uiTxMsgLen = EPL_DLLK_BUFLEN_EMPTY;
// register multicast MACs in ethernet driver
AmiSetQword48ToBe(&abMulticastMac[0], EPL_C_DLL_MULTICAST_SOC);
Ret = EdrvDefineRxMacAddrEntry(abMulticastMac);
AmiSetQword48ToBe(&abMulticastMac[0], EPL_C_DLL_MULTICAST_SOA);
Ret = EdrvDefineRxMacAddrEntry(abMulticastMac);
AmiSetQword48ToBe(&abMulticastMac[0], EPL_C_DLL_MULTICAST_PRES);
Ret = EdrvDefineRxMacAddrEntry(abMulticastMac);
AmiSetQword48ToBe(&abMulticastMac[0], EPL_C_DLL_MULTICAST_ASND);
Ret = EdrvDefineRxMacAddrEntry(abMulticastMac);
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
if (NmtState >= kEplNmtMsNotActive)
{ // local node is MN
unsigned int uiIndex;
// SoC
uiFrameSize = EPL_C_DLL_MINSIZE_SOC;
Ret = EplDllkCreateTxFrame(&uiHandle, &pTxFrame, &uiFrameSize, kEplMsgTypeSoc, kEplDllAsndNotDefined);
if (Ret != kEplSuccessful)
{ // error occured while registering Tx frame
goto Exit;
}
// SoA
uiFrameSize = EPL_C_DLL_MINSIZE_SOA;
Ret = EplDllkCreateTxFrame(&uiHandle, &pTxFrame, &uiFrameSize, kEplMsgTypeSoa, kEplDllAsndNotDefined);
if (Ret != kEplSuccessful)
{ // error occured while registering Tx frame
goto Exit;
}
for (uiIndex = 0; uiIndex < tabentries (EplDllkInstance_g.m_aNodeInfo); uiIndex++)
{
// EplDllkInstance_g.m_aNodeInfo[uiIndex].m_uiNodeId = uiIndex + 1;
EplDllkInstance_g.m_aNodeInfo[uiIndex].m_wPresPayloadLimit = (WORD) EplDllkInstance_g.m_DllConfigParam.m_uiIsochrRxMaxPayload;
}
// calculate cycle length
EplDllkInstance_g.m_ullFrameTimeout = 1000LL
* ((unsigned long long) EplDllkInstance_g.m_DllConfigParam.m_dwCycleLen);
}
#endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
Ret = EplDllkCalAsyncClearBuffer();
break;
}
case kEplEventTypeDllkDestroy:
{
// destroy all data structures
NmtState = *((tEplNmtState*)pEvent_p->m_pArg);
// delete Tx frames
Ret = EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_IDENTRES);
if (Ret != kEplSuccessful)
{ // error occured while deregistering Tx frame
goto Exit;
}
Ret = EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_STATUSRES);
if (Ret != kEplSuccessful)
{ // error occured while deregistering Tx frame
goto Exit;
}
Ret = EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_PRES);
if (Ret != kEplSuccessful)
{ // error occured while deregistering Tx frame
goto Exit;
}
Ret = EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_NMTREQ);
if (Ret != kEplSuccessful)
{ // error occured while deregistering Tx frame
goto Exit;
}
Ret = EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_NONEPL);
if (Ret != kEplSuccessful)
{ // error occured while deregistering Tx frame
goto Exit;
}
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
if (NmtState >= kEplNmtMsNotActive)
{ // local node was MN
unsigned int uiIndex;
Ret = EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_SOC);
if (Ret != kEplSuccessful)
{ // error occured while deregistering Tx frame
goto Exit;
}
Ret = EplDllkDeleteTxFrame(EPL_DLLK_TXFRAME_SOA);
if (Ret != kEplSuccessful)
{ // error occured while deregistering Tx frame
goto Exit;
}
for (uiIndex = 0; uiIndex < tabentries (EplDllkInstance_g.m_aNodeInfo); uiIndex++)
{
if (EplDllkInstance_g.m_aNodeInfo[uiIndex].m_pPreqTxBuffer != NULL)
{
uiHandle = EplDllkInstance_g.m_aNodeInfo[uiIndex].m_pPreqTxBuffer - EplDllkInstance_g.m_pTxBuffer;
EplDllkInstance_g.m_aNodeInfo[uiIndex].m_pPreqTxBuffer = NULL;
Ret = EplDllkDeleteTxFrame(uiHandle);
if (Ret != kEplSuccessful)
{ // error occured while deregistering Tx frame
goto Exit;
}
}
EplDllkInstance_g.m_aNodeInfo[uiIndex].m_wPresPayloadLimit = 0xFFFF;
}
}
#endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
// deregister multicast MACs in ethernet driver
AmiSetQword48ToBe(&abMulticastMac[0], EPL_C_DLL_MULTICAST_SOC);
Ret = EdrvUndefineRxMacAddrEntry(abMulticastMac);
AmiSetQword48ToBe(&abMulticastMac[0], EPL_C_DLL_MULTICAST_SOA);
Ret = EdrvUndefineRxMacAddrEntry(abMulticastMac);
AmiSetQword48ToBe(&abMulticastMac[0], EPL_C_DLL_MULTICAST_PRES);
Ret = EdrvUndefineRxMacAddrEntry(abMulticastMac);
AmiSetQword48ToBe(&abMulticastMac[0], EPL_C_DLL_MULTICAST_ASND);
Ret = EdrvUndefineRxMacAddrEntry(abMulticastMac);
// delete timer
#if EPL_TIMER_USE_HIGHRES != FALSE
Ret = EplTimerHighReskDeleteTimer(&EplDllkInstance_g.m_TimerHdlCycle);
#endif
break;
}
case kEplEventTypeDllkFillTx:
{
// fill TxBuffer of specified priority with new frame if empty
pTxFrame = NULL;
AsyncReqPriority = *((tEplDllAsyncReqPriority *) pEvent_p->m_pArg);
switch (AsyncReqPriority)
{
case kEplDllAsyncReqPrioNmt: // NMT request priority
{
pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ];
if (pTxBuffer->m_pbBuffer != NULL)
{ // NmtRequest does exist
// check if frame is empty and not being filled
if (pTxBuffer->m_uiTxMsgLen == EPL_DLLK_BUFLEN_EMPTY)
{
// mark Tx buffer as filling is in process
pTxBuffer->m_uiTxMsgLen = EPL_DLLK_BUFLEN_FILLING;
// set max buffer size as input parameter
uiFrameSize = pTxBuffer->m_uiMaxBufferLen;
// copy frame from shared loop buffer to Tx buffer
Ret = EplDllkCalAsyncGetTxFrame(
pTxBuffer->m_pbBuffer, &uiFrameSize, AsyncReqPriority);
if (Ret == kEplSuccessful)
{
pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
Ret = EplDllkCheckFrame(pTxFrame, uiFrameSize);
// set buffer valid
pTxBuffer->m_uiTxMsgLen = uiFrameSize;
}
else if (Ret == kEplDllAsyncTxBufferEmpty)
{ // empty Tx buffer is not a real problem
// so just ignore it
Ret = kEplSuccessful;
// mark Tx buffer as empty
pTxBuffer->m_uiTxMsgLen = EPL_DLLK_BUFLEN_EMPTY;
}
}
}
break;
}
default: // generic priority
{
pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NONEPL];
if (pTxBuffer->m_pbBuffer != NULL)
{ // non-EPL frame does exist
// check if frame is empty and not being filled
if (pTxBuffer->m_uiTxMsgLen == EPL_DLLK_BUFLEN_EMPTY)
{
// mark Tx buffer as filling is in process
pTxBuffer->m_uiTxMsgLen = EPL_DLLK_BUFLEN_FILLING;
// set max buffer size as input parameter
uiFrameSize = pTxBuffer->m_uiMaxBufferLen;
// copy frame from shared loop buffer to Tx buffer
Ret = EplDllkCalAsyncGetTxFrame(
pTxBuffer->m_pbBuffer, &uiFrameSize, AsyncReqPriority);
if (Ret == kEplSuccessful)
{
pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
Ret = EplDllkCheckFrame(pTxFrame, uiFrameSize);
// set buffer valid
pTxBuffer->m_uiTxMsgLen = uiFrameSize;
}
else if (Ret == kEplDllAsyncTxBufferEmpty)
{ // empty Tx buffer is not a real problem
// so just ignore it
Ret = kEplSuccessful;
// mark Tx buffer as empty
pTxBuffer->m_uiTxMsgLen = EPL_DLLK_BUFLEN_EMPTY;
}
}
}
break;
}
}
NmtState = EplNmtkGetNmtState();
if ((NmtState == kEplNmtCsBasicEthernet) || (NmtState == kEplNmtMsBasicEthernet))
{ // send frame immediately
if (pTxFrame != NULL)
{ // frame is present
// padding is done by Edrv or ethernet controller
Ret = EdrvSendTxMsg(pTxBuffer);
}
else
{ // no frame moved to TxBuffer
// check if TxBuffers contain unsent frames
if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen > EPL_DLLK_BUFLEN_EMPTY)
{ // NMT request Tx buffer contains a frame
Ret = EdrvSendTxMsg(
&EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ]);
}
else if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NONEPL].m_uiTxMsgLen > EPL_DLLK_BUFLEN_EMPTY)
{ // non-EPL Tx buffer contains a frame
Ret = EdrvSendTxMsg(
&EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NONEPL]);
}
if (Ret == kEplInvalidOperation)
{ // ignore error if caused by already active transmission
Ret = kEplSuccessful;
}
}
// reset PRes flag 2
EplDllkInstance_g.m_bFlag2 = 0;
}
else
{
// update Flag 2 (PR, RS)
Ret = EplDllkCalAsyncGetTxCount(&AsyncReqPriority, &uiFrameCount);
if (AsyncReqPriority == kEplDllAsyncReqPrioNmt)
{ // non-empty FIFO with hightest priority is for NMT requests
if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen > EPL_DLLK_BUFLEN_EMPTY)
{ // NMT request Tx buffer contains a frame
// add one more frame
uiFrameCount++;
}
}
else
{ // non-empty FIFO with highest priority is for generic frames
if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen > EPL_DLLK_BUFLEN_EMPTY)
{ // NMT request Tx buffer contains a frame
// use NMT request FIFO, because of higher priority
uiFrameCount = 1;
AsyncReqPriority = kEplDllAsyncReqPrioNmt;
}
else if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NONEPL].m_uiTxMsgLen > EPL_DLLK_BUFLEN_EMPTY)
{ // non-EPL Tx buffer contains a frame
// use NMT request FIFO, because of higher priority
// add one more frame
uiFrameCount++;
}
}
if (uiFrameCount > 7)
{ // limit frame request to send counter to 7
uiFrameCount = 7;
}
if (uiFrameCount > 0)
{
EplDllkInstance_g.m_bFlag2 =
(BYTE) (((AsyncReqPriority << EPL_FRAME_FLAG2_PR_SHIFT) & EPL_FRAME_FLAG2_PR)
| (uiFrameCount & EPL_FRAME_FLAG2_RS));
}
else
{
EplDllkInstance_g.m_bFlag2 = 0;
}
}
break;
}
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
case kEplEventTypeDllkStartReducedCycle:
{
// start the reduced cycle by programming the cycle timer
// it is issued by NMT MN module, when PreOp1 is entered
// clear the asynchronous queues
Ret = EplDllkCalAsyncClearQueues();
// reset cycle counter (everytime a SoA is triggerd in PreOp1 the counter is incremented
// and when it reaches EPL_C_DLL_PREOP1_START_CYCLES the SoA may contain invitations)
EplDllkInstance_g.m_uiCycleCount = 0;
// remove any CN from isochronous phase
while (EplDllkInstance_g.m_pFirstNodeInfo != NULL)
{
EplDllkDeleteNode(EplDllkInstance_g.m_pFirstNodeInfo->m_uiNodeId);
}
// change state to NonCyclic,
// hence EplDllkChangeState() will not ignore the next call
EplDllkInstance_g.m_DllState = kEplDllMsNonCyclic;
#if EPL_TIMER_USE_HIGHRES != FALSE
if (EplDllkInstance_g.m_DllConfigParam.m_dwAsyncSlotTimeout != 0)
{
Ret = EplTimerHighReskModifyTimerNs(&EplDllkInstance_g.m_TimerHdlCycle,
EplDllkInstance_g.m_DllConfigParam.m_dwAsyncSlotTimeout,
EplDllkCbMnTimerCycle,
0L,
FALSE);
}
#endif
break;
}
#endif
#if EPL_DLL_PRES_READY_AFTER_SOA != FALSE
case kEplEventTypeDllkPresReady:
{
// post PRes to transmit FIFO
NmtState = EplNmtkGetNmtState();
if (NmtState != kEplNmtCsBasicEthernet)
{
// Does PRes exist?
if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_PRES].m_pbBuffer != NULL)
{ // PRes does exist
pTxFrame = (tEplFrame *) EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_PRES].m_pbBuffer;
// update frame (NMT state, RD, RS, PR, MS, EN flags)
if (NmtState < kEplNmtCsPreOperational2)
{ // NMT state is not PreOp2, ReadyToOp or Op
// fake NMT state PreOp2, because PRes will be sent only in PreOp2 or greater
NmtState = kEplNmtCsPreOperational2;
}
AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bNmtStatus, (BYTE) NmtState);
AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bFlag2, EplDllkInstance_g.m_bFlag2);
if (NmtState != kEplNmtCsOperational)
{ // mark PDO as invalid in NMT state Op
// $$$ reset only RD flag; set other flags appropriately
AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bFlag1, 0);
}
// $$$ make function that updates Pres, StatusRes
// mark PRes frame as ready for transmission
Ret = EdrvTxMsgReady(&EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_PRES]);
}
}
break;
}
#endif
default:
{
ASSERTMSG(FALSE, "EplDllkProcess(): unhandled event type!\n");
}
}
Exit:
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkConfig
//
// Description: configure parameters of DLL
//
// Parameters: pDllConfigParam_p = configuration parameters
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplDllkConfig(tEplDllConfigParam * pDllConfigParam_p)
{
tEplKernel Ret = kEplSuccessful;
// d.k. check of NMT state disabled, because CycleLen is programmed at run time by MN without reset of CN
/*tEplNmtState NmtState;
NmtState = EplNmtkGetNmtState();
if (NmtState > kEplNmtGsResetConfiguration)
{ // only allowed in state DLL_GS_INIT
Ret = kEplInvalidOperation;
goto Exit;
}
*/
EPL_MEMCPY (&EplDllkInstance_g.m_DllConfigParam, pDllConfigParam_p,
(pDllConfigParam_p->m_uiSizeOfStruct < sizeof (tEplDllConfigParam) ?
pDllConfigParam_p->m_uiSizeOfStruct : sizeof (tEplDllConfigParam)));
if ((EplDllkInstance_g.m_DllConfigParam.m_dwCycleLen != 0)
&& (EplDllkInstance_g.m_DllConfigParam.m_dwLossOfFrameTolerance != 0))
{ // monitor EPL cycle, calculate frame timeout
EplDllkInstance_g.m_ullFrameTimeout = (1000LL
* ((unsigned long long) EplDllkInstance_g.m_DllConfigParam.m_dwCycleLen))
+ ((unsigned long long) EplDllkInstance_g.m_DllConfigParam.m_dwLossOfFrameTolerance);
}
else
{
EplDllkInstance_g.m_ullFrameTimeout = 0LL;
}
if (EplDllkInstance_g.m_DllConfigParam.m_fAsyncOnly != FALSE)
{ // it is configured as async-only CN
// disable multiplexed cycle, that m_uiCycleCount will not be incremented spuriously on SoC
EplDllkInstance_g.m_DllConfigParam.m_uiMultiplCycleCnt = 0;
}
//Exit:
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkSetIdentity
//
// Description: configure identity of local node for IdentResponse
//
// Parameters: pDllIdentParam_p = identity
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplDllkSetIdentity(tEplDllIdentParam * pDllIdentParam_p)
{
tEplKernel Ret = kEplSuccessful;
EPL_MEMCPY (&EplDllkInstance_g.m_DllIdentParam, pDllIdentParam_p,
(pDllIdentParam_p->m_uiSizeOfStruct < sizeof (tEplDllIdentParam) ?
pDllIdentParam_p->m_uiSizeOfStruct : sizeof (tEplDllIdentParam)));
// $$$ if IdentResponse frame exists update it
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkRegAsyncHandler
//
// Description: registers handler for non-EPL frames
//
// Parameters: pfnDllkCbAsync_p = pointer to callback function
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplDllkRegAsyncHandler(tEplDllkCbAsync pfnDllkCbAsync_p)
{
tEplKernel Ret = kEplSuccessful;
if (EplDllkInstance_g.m_pfnCbAsync == NULL)
{ // no handler registered yet
EplDllkInstance_g.m_pfnCbAsync = pfnDllkCbAsync_p;
}
else
{ // handler already registered
Ret = kEplDllCbAsyncRegistered;
}
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkDeregAsyncHandler
//
// Description: deregisters handler for non-EPL frames
//
// Parameters: pfnDllkCbAsync_p = pointer to callback function
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplDllkDeregAsyncHandler(tEplDllkCbAsync pfnDllkCbAsync_p)
{
tEplKernel Ret = kEplSuccessful;
if (EplDllkInstance_g.m_pfnCbAsync == pfnDllkCbAsync_p)
{ // same handler is registered
// deregister it
EplDllkInstance_g.m_pfnCbAsync = NULL;
}
else
{ // wrong handler or no handler registered
Ret = kEplDllCbAsyncRegistered;
}
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkSetAsndServiceIdFilter()
//
// Description: sets the specified node ID filter for the specified
// AsndServiceId. It registers C_DLL_MULTICAST_ASND in ethernet
// driver if any AsndServiceId is open.
//
// Parameters: ServiceId_p = ASnd Service ID
// Filter_p = node ID filter
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplDllkSetAsndServiceIdFilter(tEplDllAsndServiceId ServiceId_p, tEplDllAsndFilter Filter_p)
{
tEplKernel Ret = kEplSuccessful;
if (ServiceId_p < tabentries (EplDllkInstance_g.m_aAsndFilter))
{
EplDllkInstance_g.m_aAsndFilter[ServiceId_p] = Filter_p;
}
return Ret;
}
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
//---------------------------------------------------------------------------
//
// Function: EplDllkSetFlag1OfNode()
//
// Description: sets Flag1 (for PReq and SoA) of the specified node ID.
//
// Parameters: uiNodeId_p = node ID
// bSoaFlag1_p = flag1
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplDllkSetFlag1OfNode(unsigned int uiNodeId_p, BYTE bSoaFlag1_p)
{
tEplKernel Ret = kEplSuccessful;
tEplDllkNodeInfo* pNodeInfo;
pNodeInfo = EplDllkGetNodeInfo(uiNodeId_p);
if (pNodeInfo == NULL)
{ // no node info structure available
Ret = kEplDllNoNodeInfo;
goto Exit;
}
// store flag1 in internal node info structure
pNodeInfo->m_bSoaFlag1 = bSoaFlag1_p;
Exit:
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkGetFirstNodeInfo()
//
// Description: returns first info structure of first node in isochronous phase.
// It is only useful for ErrorHandlerk module.
//
// Parameters: ppNodeInfo_p = pointer to pointer of internal node info structure
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplDllkGetFirstNodeInfo(tEplDllkNodeInfo** ppNodeInfo_p)
{
tEplKernel Ret = kEplSuccessful;
*ppNodeInfo_p = EplDllkInstance_g.m_pFirstNodeInfo;
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkAddNode()
//
// Description: adds the specified node to the isochronous phase.
//
// Parameters: pNodeInfo_p = pointer of node info structure
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplDllkAddNode(tEplDllNodeInfo * pNodeInfo_p)
{
tEplKernel Ret = kEplSuccessful;
tEplDllkNodeInfo* pIntNodeInfo;
tEplDllkNodeInfo** ppIntNodeInfo;
unsigned int uiHandle;
tEplFrame* pFrame;
unsigned int uiFrameSize;
pIntNodeInfo = EplDllkGetNodeInfo(pNodeInfo_p->m_uiNodeId);
if (pIntNodeInfo == NULL)
{ // no node info structure available
Ret = kEplDllNoNodeInfo;
goto Exit;
}
EPL_DLLK_DBG_POST_TRACE_VALUE(kEplEventTypeDllkAddNode,
pNodeInfo_p->m_uiNodeId,
0);
// copy node configuration
pIntNodeInfo->m_dwPresTimeout = pNodeInfo_p->m_dwPresTimeout;
pIntNodeInfo->m_wPresPayloadLimit = pNodeInfo_p->m_wPresPayloadLimit;
// $$$ d.k.: actually add node only if MN. On CN it is sufficient to update the node configuration
if (pNodeInfo_p->m_uiNodeId == EplDllkInstance_g.m_DllConfigParam.m_uiNodeId)
{ // we shall send PRes ourself
// insert our node at the end of the list
ppIntNodeInfo = &EplDllkInstance_g.m_pFirstNodeInfo;
while ((*ppIntNodeInfo != NULL) && ((*ppIntNodeInfo)->m_pNextNodeInfo != NULL))
{
ppIntNodeInfo = &(*ppIntNodeInfo)->m_pNextNodeInfo;
}
if (*ppIntNodeInfo != NULL)
{
if ((*ppIntNodeInfo)->m_uiNodeId == pNodeInfo_p->m_uiNodeId)
{ // node was already added to list
// $$$ d.k. maybe this should be an error
goto Exit;
}
else
{ // add our node at the end of the list
ppIntNodeInfo = &(*ppIntNodeInfo)->m_pNextNodeInfo;
}
}
// set "PReq"-TxBuffer to PRes-TxBuffer
pIntNodeInfo->m_pPreqTxBuffer = &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_PRES];
}
else
{ // normal CN shall be added to isochronous phase
// insert node into list in ascending order
ppIntNodeInfo = &EplDllkInstance_g.m_pFirstNodeInfo;
while ((*ppIntNodeInfo != NULL)
&& ((*ppIntNodeInfo)->m_uiNodeId < pNodeInfo_p->m_uiNodeId)
&& ((*ppIntNodeInfo)->m_uiNodeId != EplDllkInstance_g.m_DllConfigParam.m_uiNodeId))
{
ppIntNodeInfo = &(*ppIntNodeInfo)->m_pNextNodeInfo;
}
if ((*ppIntNodeInfo != NULL) && ((*ppIntNodeInfo)->m_uiNodeId == pNodeInfo_p->m_uiNodeId))
{ // node was already added to list
// $$$ d.k. maybe this should be an error
goto Exit;
}
}
// initialize elements of internal node info structure
pIntNodeInfo->m_bSoaFlag1 = 0;
pIntNodeInfo->m_fSoftDelete = FALSE;
pIntNodeInfo->m_NmtState = kEplNmtCsNotActive;
if (pIntNodeInfo->m_pPreqTxBuffer == NULL)
{ // create TxBuffer entry
uiFrameSize = pNodeInfo_p->m_wPreqPayloadLimit + 24;
Ret = EplDllkCreateTxFrame(&uiHandle, &pFrame, &uiFrameSize, kEplMsgTypePreq, kEplDllAsndNotDefined);
if (Ret != kEplSuccessful)
{
goto Exit;
}
pIntNodeInfo->m_pPreqTxBuffer = &EplDllkInstance_g.m_pTxBuffer[uiHandle];
AmiSetByteToLe(&pFrame->m_le_bDstNodeId, (BYTE) pNodeInfo_p->m_uiNodeId);
// set up destination MAC address
EPL_MEMCPY(pFrame->m_be_abDstMac, pIntNodeInfo->m_be_abMacAddr, 6);
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
{
tEplFrameInfo FrameInfo;
// initially encode TPDO -> inform PDO module
FrameInfo.m_pFrame = pFrame;
FrameInfo.m_uiFrameSize = uiFrameSize;
Ret = EplPdokCbPdoTransmitted(&FrameInfo);
}
#endif
}
pIntNodeInfo->m_ulDllErrorEvents = 0L;
// add node to list
pIntNodeInfo->m_pNextNodeInfo = *ppIntNodeInfo;
*ppIntNodeInfo = pIntNodeInfo;
Exit:
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkDeleteNode()
//
// Description: removes the specified node from the isochronous phase.
//
// Parameters: uiNodeId_p = node ID
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplDllkDeleteNode(unsigned int uiNodeId_p)
{
tEplKernel Ret = kEplSuccessful;
tEplDllkNodeInfo* pIntNodeInfo;
tEplDllkNodeInfo** ppIntNodeInfo;
unsigned int uiHandle;
pIntNodeInfo = EplDllkGetNodeInfo(uiNodeId_p);
if (pIntNodeInfo == NULL)
{ // no node info structure available
Ret = kEplDllNoNodeInfo;
goto Exit;
}
EPL_DLLK_DBG_POST_TRACE_VALUE(kEplEventTypeDllkDelNode,
uiNodeId_p,
0);
// search node in whole list
ppIntNodeInfo = &EplDllkInstance_g.m_pFirstNodeInfo;
while ((*ppIntNodeInfo != NULL) && ((*ppIntNodeInfo)->m_uiNodeId != uiNodeId_p))
{
ppIntNodeInfo = &(*ppIntNodeInfo)->m_pNextNodeInfo;
}
if ((*ppIntNodeInfo == NULL) || ((*ppIntNodeInfo)->m_uiNodeId != uiNodeId_p))
{ // node was not found in list
// $$$ d.k. maybe this should be an error
goto Exit;
}
// remove node from list
*ppIntNodeInfo = pIntNodeInfo->m_pNextNodeInfo;
if ((pIntNodeInfo->m_pPreqTxBuffer != NULL)
&& (pIntNodeInfo->m_pPreqTxBuffer != &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_PRES]))
{ // delete TxBuffer entry
uiHandle = pIntNodeInfo->m_pPreqTxBuffer - EplDllkInstance_g.m_pTxBuffer;
pIntNodeInfo->m_pPreqTxBuffer = NULL;
Ret = EplDllkDeleteTxFrame(uiHandle);
/* if (Ret != kEplSuccessful)
{
goto Exit;
}*/
}
Exit:
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkSoftDeleteNode()
//
// Description: removes the specified node not immediately from the isochronous phase.
// Instead the will be removed after error (late/loss PRes) without
// charging the error.
//
// Parameters: uiNodeId_p = node ID
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel EplDllkSoftDeleteNode(unsigned int uiNodeId_p)
{
tEplKernel Ret = kEplSuccessful;
tEplDllkNodeInfo* pIntNodeInfo;
pIntNodeInfo = EplDllkGetNodeInfo(uiNodeId_p);
if (pIntNodeInfo == NULL)
{ // no node info structure available
Ret = kEplDllNoNodeInfo;
goto Exit;
}
EPL_DLLK_DBG_POST_TRACE_VALUE(kEplEventTypeDllkSoftDelNode,
uiNodeId_p,
0);
pIntNodeInfo->m_fSoftDelete = TRUE;
Exit:
return Ret;
}
#endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
//=========================================================================//
// //
// P R I V A T E F U N C T I O N S //
// //
//=========================================================================//
//---------------------------------------------------------------------------
//
// Function: EplDllkChangeState
//
// Description: change DLL state on event and diagnose some communication errors
//
// Parameters: NmtEvent_p = DLL event (wrapped in NMT event)
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
static tEplKernel EplDllkChangeState(tEplNmtEvent NmtEvent_p, tEplNmtState NmtState_p)
{
tEplKernel Ret = kEplSuccessful;
tEplEvent Event;
tEplErrorHandlerkEvent DllEvent;
DllEvent.m_ulDllErrorEvents = 0;
DllEvent.m_uiNodeId = 0;
DllEvent.m_NmtState = NmtState_p;
switch (NmtState_p)
{
case kEplNmtGsOff:
case kEplNmtGsInitialising:
case kEplNmtGsResetApplication:
case kEplNmtGsResetCommunication:
case kEplNmtGsResetConfiguration:
case kEplNmtCsBasicEthernet:
// enter DLL_GS_INIT
EplDllkInstance_g.m_DllState = kEplDllGsInit;
break;
case kEplNmtCsNotActive:
case kEplNmtCsPreOperational1:
// reduced EPL cycle is active
if (NmtEvent_p == kEplNmtEventDllCeSoc)
{ // SoC received
// enter DLL_CS_WAIT_PREQ
EplDllkInstance_g.m_DllState = kEplDllCsWaitPreq;
}
else
{
// enter DLL_GS_INIT
EplDllkInstance_g.m_DllState = kEplDllGsInit;
}
break;
case kEplNmtCsPreOperational2:
case kEplNmtCsReadyToOperate:
case kEplNmtCsOperational:
// full EPL cycle is active
switch (EplDllkInstance_g.m_DllState)
{
case kEplDllCsWaitPreq:
switch (NmtEvent_p)
{
// DLL_CT2
case kEplNmtEventDllCePreq:
// enter DLL_CS_WAIT_SOA
DllEvent.m_ulDllErrorEvents |= EPL_DLL_ERR_CN_RECVD_PREQ;
EplDllkInstance_g.m_DllState = kEplDllCsWaitSoa;
break;
// DLL_CT8
case kEplNmtEventDllCeFrameTimeout:
if (NmtState_p == kEplNmtCsPreOperational2)
{ // ignore frame timeout in PreOp2,
// because the previously configured cycle len
// may be wrong.
// 2008/10/15 d.k. If it would not be ignored,
// we would go cyclically to PreOp1 and on next
// SoC back to PreOp2.
break;
}
// report DLL_CEV_LOSS_SOC and DLL_CEV_LOSS_SOA
DllEvent.m_ulDllErrorEvents |= EPL_DLL_ERR_CN_LOSS_SOA | EPL_DLL_ERR_CN_LOSS_SOC;
// enter DLL_CS_WAIT_SOC
EplDllkInstance_g.m_DllState = kEplDllCsWaitSoc;
break;
case kEplNmtEventDllCeSoa:
// check if multiplexed and PReq should have been received in this cycle
// and if >= NMT_CS_READY_TO_OPERATE
if ((EplDllkInstance_g.m_uiCycleCount == 0)
&& (NmtState_p >= kEplNmtCsReadyToOperate))
{ // report DLL_CEV_LOSS_OF_PREQ
DllEvent.m_ulDllErrorEvents |= EPL_DLL_ERR_CN_LOSS_PREQ;
}
// enter DLL_CS_WAIT_SOC
EplDllkInstance_g.m_DllState = kEplDllCsWaitSoc;
break;
// DLL_CT7
case kEplNmtEventDllCeSoc:
case kEplNmtEventDllCeAsnd:
// report DLL_CEV_LOSS_SOA
DllEvent.m_ulDllErrorEvents |= EPL_DLL_ERR_CN_LOSS_SOA;
case kEplNmtEventDllCePres:
default:
// remain in this state
break;
}
break;
case kEplDllCsWaitSoc:
switch (NmtEvent_p)
{
// DLL_CT1
case kEplNmtEventDllCeSoc:
// start of cycle and isochronous phase
// enter DLL_CS_WAIT_PREQ
EplDllkInstance_g.m_DllState = kEplDllCsWaitPreq;
break;
// DLL_CT4
// case kEplNmtEventDllCePres:
case kEplNmtEventDllCeFrameTimeout:
if (NmtState_p == kEplNmtCsPreOperational2)
{ // ignore frame timeout in PreOp2,
// because the previously configured cycle len
// may be wrong.
// 2008/10/15 d.k. If it would not be ignored,
// we would go cyclically to PreOp1 and on next
// SoC back to PreOp2.
break;
}
// fall through
case kEplNmtEventDllCePreq:
case kEplNmtEventDllCeSoa:
// report DLL_CEV_LOSS_SOC
DllEvent.m_ulDllErrorEvents |= EPL_DLL_ERR_CN_LOSS_SOC;
case kEplNmtEventDllCeAsnd:
default:
// remain in this state
break;
}
break;
case kEplDllCsWaitSoa:
switch (NmtEvent_p)
{
case kEplNmtEventDllCeFrameTimeout:
// DLL_CT3
if (NmtState_p == kEplNmtCsPreOperational2)
{ // ignore frame timeout in PreOp2,
// because the previously configured cycle len
// may be wrong.
// 2008/10/15 d.k. If it would not be ignored,
// we would go cyclically to PreOp1 and on next
// SoC back to PreOp2.
break;
}
// fall through
case kEplNmtEventDllCePreq:
// report DLL_CEV_LOSS_SOC and DLL_CEV_LOSS_SOA
DllEvent.m_ulDllErrorEvents |= EPL_DLL_ERR_CN_LOSS_SOA | EPL_DLL_ERR_CN_LOSS_SOC;
case kEplNmtEventDllCeSoa:
// enter DLL_CS_WAIT_SOC
EplDllkInstance_g.m_DllState = kEplDllCsWaitSoc;
break;
// DLL_CT9
case kEplNmtEventDllCeSoc:
// report DLL_CEV_LOSS_SOA
DllEvent.m_ulDllErrorEvents |= EPL_DLL_ERR_CN_LOSS_SOA;
// enter DLL_CS_WAIT_PREQ
EplDllkInstance_g.m_DllState = kEplDllCsWaitPreq;
break;
// DLL_CT10
case kEplNmtEventDllCeAsnd:
// report DLL_CEV_LOSS_SOA
DllEvent.m_ulDllErrorEvents |= EPL_DLL_ERR_CN_LOSS_SOA;
case kEplNmtEventDllCePres:
default:
// remain in this state
break;
}
break;
case kEplDllGsInit:
// enter DLL_CS_WAIT_PREQ
EplDllkInstance_g.m_DllState = kEplDllCsWaitPreq;
break;
default:
break;
}
break;
case kEplNmtCsStopped:
// full EPL cycle is active, but without PReq/PRes
switch (EplDllkInstance_g.m_DllState)
{
case kEplDllCsWaitPreq:
switch (NmtEvent_p)
{
// DLL_CT2
case kEplNmtEventDllCePreq:
// enter DLL_CS_WAIT_SOA
EplDllkInstance_g.m_DllState = kEplDllCsWaitSoa;
break;
// DLL_CT8
case kEplNmtEventDllCeFrameTimeout:
// report DLL_CEV_LOSS_SOC and DLL_CEV_LOSS_SOA
DllEvent.m_ulDllErrorEvents |= EPL_DLL_ERR_CN_LOSS_SOA | EPL_DLL_ERR_CN_LOSS_SOC;
case kEplNmtEventDllCeSoa:
// NMT_CS_STOPPED active
// it is Ok if no PReq was received
// enter DLL_CS_WAIT_SOC
EplDllkInstance_g.m_DllState = kEplDllCsWaitSoc;
break;
// DLL_CT7
case kEplNmtEventDllCeSoc:
case kEplNmtEventDllCeAsnd:
// report DLL_CEV_LOSS_SOA
DllEvent.m_ulDllErrorEvents |= EPL_DLL_ERR_CN_LOSS_SOA;
case kEplNmtEventDllCePres:
default:
// remain in this state
break;
}
break;
case kEplDllCsWaitSoc:
switch (NmtEvent_p)
{
// DLL_CT1
case kEplNmtEventDllCeSoc:
// start of cycle and isochronous phase
// enter DLL_CS_WAIT_SOA
EplDllkInstance_g.m_DllState = kEplDllCsWaitSoa;
break;
// DLL_CT4
// case kEplNmtEventDllCePres:
case kEplNmtEventDllCePreq:
case kEplNmtEventDllCeSoa:
case kEplNmtEventDllCeFrameTimeout:
// report DLL_CEV_LOSS_SOC
DllEvent.m_ulDllErrorEvents |= EPL_DLL_ERR_CN_LOSS_SOC;
case kEplNmtEventDllCeAsnd:
default:
// remain in this state
break;
}
break;
case kEplDllCsWaitSoa:
switch (NmtEvent_p)
{
// DLL_CT3
case kEplNmtEventDllCeFrameTimeout:
// report DLL_CEV_LOSS_SOC and DLL_CEV_LOSS_SOA
DllEvent.m_ulDllErrorEvents |= EPL_DLL_ERR_CN_LOSS_SOA | EPL_DLL_ERR_CN_LOSS_SOC;
case kEplNmtEventDllCeSoa:
// enter DLL_CS_WAIT_SOC
EplDllkInstance_g.m_DllState = kEplDllCsWaitSoc;
break;
// DLL_CT9
case kEplNmtEventDllCeSoc:
// report DLL_CEV_LOSS_SOA
DllEvent.m_ulDllErrorEvents |= EPL_DLL_ERR_CN_LOSS_SOA;
// remain in DLL_CS_WAIT_SOA
break;
// DLL_CT10
case kEplNmtEventDllCeAsnd:
// report DLL_CEV_LOSS_SOA
DllEvent.m_ulDllErrorEvents |= EPL_DLL_ERR_CN_LOSS_SOA;
case kEplNmtEventDllCePreq:
// NMT_CS_STOPPED active and we do not expect any PReq
// so just ignore it
case kEplNmtEventDllCePres:
default:
// remain in this state
break;
}
break;
case kEplDllGsInit:
default:
// enter DLL_CS_WAIT_PREQ
EplDllkInstance_g.m_DllState = kEplDllCsWaitSoa;
break;
}
break;
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
case kEplNmtMsNotActive:
case kEplNmtMsBasicEthernet:
break;
case kEplNmtMsPreOperational1:
// reduced EPL cycle is active
if (EplDllkInstance_g.m_DllState != kEplDllMsNonCyclic)
{ // stop cycle timer
#if EPL_TIMER_USE_HIGHRES != FALSE
Ret = EplTimerHighReskDeleteTimer(&EplDllkInstance_g.m_TimerHdlCycle);
#endif
EplDllkInstance_g.m_DllState = kEplDllMsNonCyclic;
// stop further processing,
// because it will be restarted by NMT MN module
break;
}
switch (NmtEvent_p)
{
case kEplNmtEventDllMeSocTrig:
case kEplNmtEventDllCeAsnd:
{ // because of reduced EPL cycle SoA shall be triggered, not SoC
tEplDllState DummyDllState;
Ret = EplDllkAsyncFrameNotReceived(EplDllkInstance_g.m_LastReqServiceId,
EplDllkInstance_g.m_uiLastTargetNodeId);
// go ahead and send SoA
Ret = EplDllkMnSendSoa(NmtState_p,
&DummyDllState,
(EplDllkInstance_g.m_uiCycleCount >= EPL_C_DLL_PREOP1_START_CYCLES));
// increment cycle counter to detect if EPL_C_DLL_PREOP1_START_CYCLES empty cycles are elapsed
EplDllkInstance_g.m_uiCycleCount++;
// reprogram timer
#if EPL_TIMER_USE_HIGHRES != FALSE
if (EplDllkInstance_g.m_DllConfigParam.m_dwAsyncSlotTimeout != 0)
{
Ret = EplTimerHighReskModifyTimerNs(&EplDllkInstance_g.m_TimerHdlCycle,
EplDllkInstance_g.m_DllConfigParam.m_dwAsyncSlotTimeout,
EplDllkCbMnTimerCycle,
0L,
FALSE);
}
#endif
break;
}
default:
break;
}
break;
case kEplNmtMsPreOperational2:
case kEplNmtMsReadyToOperate:
case kEplNmtMsOperational:
// full EPL cycle is active
switch (NmtEvent_p)
{
case kEplNmtEventDllMeSocTrig:
{
// update cycle counter
if (EplDllkInstance_g.m_DllConfigParam.m_uiMultiplCycleCnt > 0)
{ // multiplexed cycle active
EplDllkInstance_g.m_uiCycleCount = (EplDllkInstance_g.m_uiCycleCount + 1) % EplDllkInstance_g.m_DllConfigParam.m_uiMultiplCycleCnt;
// $$$ check multiplexed cycle restart
// -> toggle MC flag
// -> change node linked list
}
else
{ // non-multiplexed cycle active
// start with first node in isochronous phase
EplDllkInstance_g.m_pCurNodeInfo = NULL;
}
switch (EplDllkInstance_g.m_DllState)
{
case kEplDllMsNonCyclic:
{ // start continuous cycle timer
#if EPL_TIMER_USE_HIGHRES != FALSE
Ret = EplTimerHighReskModifyTimerNs(&EplDllkInstance_g.m_TimerHdlCycle,
EplDllkInstance_g.m_ullFrameTimeout,
EplDllkCbMnTimerCycle,
0L,
TRUE);
#endif
// continue with sending SoC
}
case kEplDllMsWaitAsnd:
case kEplDllMsWaitSocTrig:
{ // if m_LastReqServiceId is still valid,
// SoA was not correctly answered
// and user part has to be informed
Ret = EplDllkAsyncFrameNotReceived(EplDllkInstance_g.m_LastReqServiceId,
EplDllkInstance_g.m_uiLastTargetNodeId);
// send SoC
Ret = EplDllkMnSendSoc();
// new DLL state
EplDllkInstance_g.m_DllState = kEplDllMsWaitPreqTrig;
// start WaitSoCPReq Timer
#if EPL_TIMER_USE_HIGHRES != FALSE
Ret = EplTimerHighReskModifyTimerNs(&EplDllkInstance_g.m_TimerHdlResponse,
EplDllkInstance_g.m_DllConfigParam.m_dwWaitSocPreq,
EplDllkCbMnTimerResponse,
0L,
FALSE);
#endif
break;
}
default:
{ // wrong DLL state / cycle time exceeded
DllEvent.m_ulDllErrorEvents |= EPL_DLL_ERR_MN_CYCTIMEEXCEED;
EplDllkInstance_g.m_DllState = kEplDllMsWaitSocTrig;
break;
}
}
break;
}
case kEplNmtEventDllMePresTimeout:
{
switch (EplDllkInstance_g.m_DllState)
{
case kEplDllMsWaitPres:
{ // PRes not received
if (EplDllkInstance_g.m_pCurNodeInfo->m_fSoftDelete == FALSE)
{ // normal isochronous CN
DllEvent.m_ulDllErrorEvents |= EPL_DLL_ERR_MN_CN_LOSS_PRES;
DllEvent.m_uiNodeId = EplDllkInstance_g.m_pCurNodeInfo->m_uiNodeId;
}
else
{ // CN shall be deleted softly
Event.m_EventSink = kEplEventSinkDllkCal;
Event.m_EventType = kEplEventTypeDllkSoftDelNode;
// $$$ d.k. set Event.m_NetTime to current time
Event.m_uiSize = sizeof (unsigned int);
Event.m_pArg = &EplDllkInstance_g.m_pCurNodeInfo->m_uiNodeId;
Ret = EplEventkPost(&Event);
}
// continue with sending next PReq
}
case kEplDllMsWaitPreqTrig:
{
// send next PReq
Ret = EplDllkMnSendPreq(NmtState_p, &EplDllkInstance_g.m_DllState);
break;
}
default:
{ // wrong DLL state
break;
}
}
break;
}
case kEplNmtEventDllCePres:
{
switch (EplDllkInstance_g.m_DllState)
{
case kEplDllMsWaitPres:
{ // PRes received
// send next PReq
Ret = EplDllkMnSendPreq(NmtState_p, &EplDllkInstance_g.m_DllState);
break;
}
default:
{ // wrong DLL state
break;
}
}
break;
}
case kEplNmtEventDllMeSoaTrig:
{
switch (EplDllkInstance_g.m_DllState)
{
case kEplDllMsWaitSoaTrig:
{ // MN PRes sent
// send SoA
Ret = EplDllkMnSendSoa(NmtState_p, &EplDllkInstance_g.m_DllState, TRUE);
break;
}
default:
{ // wrong DLL state
break;
}
}
break;
}
case kEplNmtEventDllCeAsnd:
{ // ASnd has been received, but it may be not the requested one
/*
// report if SoA was correctly answered
Ret = EplDllkAsyncFrameNotReceived(EplDllkInstance_g.m_LastReqServiceId,
EplDllkInstance_g.m_uiLastTargetNodeId);
*/
if (EplDllkInstance_g.m_DllState == kEplDllMsWaitAsnd)
{
EplDllkInstance_g.m_DllState = kEplDllMsWaitSocTrig;
}
break;
}
default:
break;
}
break;
#endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
default:
break;
}
if (DllEvent.m_ulDllErrorEvents != 0)
{ // error event set -> post it to error handler
Event.m_EventSink = kEplEventSinkErrk;
Event.m_EventType = kEplEventTypeDllError;
// $$$ d.k. set Event.m_NetTime to current time
Event.m_uiSize = sizeof (DllEvent);
Event.m_pArg = &DllEvent;
Ret = EplEventkPost(&Event);
}
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkCbFrameReceived()
//
// Description: called from EdrvInterruptHandler()
//
// Parameters: pRxBuffer_p = receive buffer structure
//
// Returns: (none)
//
//
// State:
//
//---------------------------------------------------------------------------
static void EplDllkCbFrameReceived(tEdrvRxBuffer * pRxBuffer_p)
{
tEplKernel Ret = kEplSuccessful;
tEplNmtState NmtState;
tEplNmtEvent NmtEvent = kEplNmtEventNoEvent;
tEplEvent Event;
tEplFrame *pFrame;
tEplFrame *pTxFrame;
tEdrvTxBuffer *pTxBuffer = NULL;
tEplFrameInfo FrameInfo;
tEplMsgType MsgType;
tEplDllReqServiceId ReqServiceId;
unsigned int uiAsndServiceId;
unsigned int uiNodeId;
BYTE bFlag1;
BENCHMARK_MOD_02_SET(3);
NmtState = EplNmtkGetNmtState();
if (NmtState <= kEplNmtGsResetConfiguration)
{
goto Exit;
}
pFrame = (tEplFrame *) pRxBuffer_p->m_pbBuffer;
#if EDRV_EARLY_RX_INT != FALSE
switch (pRxBuffer_p->m_BufferInFrame)
{
case kEdrvBufferFirstInFrame:
{
MsgType = (tEplMsgType)AmiGetByteFromLe(&pFrame->m_le_bMessageType);
if (MsgType == kEplMsgTypePreq)
{
if (EplDllkInstance_g.m_DllState == kEplDllCsWaitPreq)
{ // PReq expected and actually received
// d.k.: The condition above is sufficent, because EPL cycle is active
// and no non-EPL frame shall be received in isochronous phase.
// start transmission PRes
// $$$ What if Tx buffer is invalid?
pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_PRES];
#if (EPL_DLL_PRES_READY_AFTER_SOA != FALSE) || (EPL_DLL_PRES_READY_AFTER_SOC != FALSE)
Ret = EdrvTxMsgStart(pTxBuffer);
#else
pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
// update frame (NMT state, RD, RS, PR, MS, EN flags)
AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bNmtStatus, (BYTE) NmtState);
AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bFlag2, EplDllkInstance_g.m_bFlag2);
if (NmtState != kEplNmtCsOperational)
{ // mark PDO as invalid in NMT state Op
// $$$ reset only RD flag; set other flags appropriately
AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bFlag1, 0);
}
// $$$ make function that updates Pres, StatusRes
// send PRes frame
Ret = EdrvSendTxMsg(pTxBuffer);
#endif
}
}
goto Exit;
}
case kEdrvBufferMiddleInFrame:
{
goto Exit;
}
case kEdrvBufferLastInFrame:
{
break;
}
}
#endif
FrameInfo.m_pFrame = pFrame;
FrameInfo.m_uiFrameSize = pRxBuffer_p->m_uiRxMsgLen;
FrameInfo.m_NetTime.m_dwNanoSec = pRxBuffer_p->m_NetTime.m_dwNanoSec;
FrameInfo.m_NetTime.m_dwSec = pRxBuffer_p->m_NetTime.m_dwSec;
if (AmiGetWordFromBe(&pFrame->m_be_wEtherType) != EPL_C_DLL_ETHERTYPE_EPL)
{ // non-EPL frame
//TRACE2("EplDllkCbFrameReceived: pfnCbAsync=0x%p SrcMAC=0x%llx\n", EplDllkInstance_g.m_pfnCbAsync, AmiGetQword48FromBe(pFrame->m_be_abSrcMac));
if (EplDllkInstance_g.m_pfnCbAsync != NULL)
{ // handler for async frames is registered
EplDllkInstance_g.m_pfnCbAsync(&FrameInfo);
}
goto Exit;
}
MsgType = (tEplMsgType)AmiGetByteFromLe(&pFrame->m_le_bMessageType);
switch (MsgType)
{
case kEplMsgTypePreq:
{
// PReq frame
// d.k.: (we assume that this PReq frame is intended for us and don't check DstNodeId)
if (AmiGetByteFromLe(&pFrame->m_le_bDstNodeId) != EplDllkInstance_g.m_DllConfigParam.m_uiNodeId)
{ // this PReq is not intended for us
goto Exit;
}
NmtEvent = kEplNmtEventDllCePreq;
if (NmtState >= kEplNmtMsNotActive)
{ // MN is active -> wrong msg type
break;
}
#if EDRV_EARLY_RX_INT == FALSE
if (NmtState >= kEplNmtCsPreOperational2)
{ // respond to and process PReq frames only in PreOp2, ReadyToOp and Op
// Does PRes exist?
pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_PRES];
if (pTxBuffer->m_pbBuffer != NULL)
{ // PRes does exist
#if (EPL_DLL_PRES_READY_AFTER_SOA != FALSE) || (EPL_DLL_PRES_READY_AFTER_SOC != FALSE)
EdrvTxMsgStart(pTxBuffer);
#else
pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
// update frame (NMT state, RD, RS, PR, MS, EN flags)
AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bNmtStatus, (BYTE) NmtState);
AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bFlag2, EplDllkInstance_g.m_bFlag2);
bFlag1 = AmiGetByteFromLe(&pFrame->m_Data.m_Preq.m_le_bFlag1);
// save EA flag
EplDllkInstance_g.m_bMnFlag1 =
(EplDllkInstance_g.m_bMnFlag1 & ~EPL_FRAME_FLAG1_EA)
| (bFlag1 & EPL_FRAME_FLAG1_EA);
// preserve MS flag
bFlag1 &= EPL_FRAME_FLAG1_MS;
// add EN flag from Error signaling module
bFlag1 |= EplDllkInstance_g.m_bFlag1 & EPL_FRAME_FLAG1_EN;
if (NmtState != kEplNmtCsOperational)
{ // mark PDO as invalid in NMT state Op
// reset only RD flag
AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bFlag1, bFlag1);
}
else
{ // leave RD flag untouched
AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bFlag1,
(AmiGetByteFromLe(&pTxFrame->m_Data.m_Pres.m_le_bFlag1) & EPL_FRAME_FLAG1_RD)
| bFlag1);
}
// $$$ update EPL_DLL_PRES_READY_AFTER_* code
// send PRes frame
Ret = EdrvSendTxMsg(pTxBuffer);
if (Ret != kEplSuccessful)
{
goto Exit;
}
#endif
}
#endif
// inform PDO module
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
if (NmtState >= kEplNmtCsReadyToOperate)
{ // inform PDO module only in ReadyToOp and Op
if (NmtState != kEplNmtCsOperational)
{
// reset RD flag and all other flags, but that does not matter, because they were processed above
AmiSetByteToLe(&pFrame->m_Data.m_Preq.m_le_bFlag1, 0);
}
// compares real frame size and PDO size
if ((unsigned int) (AmiGetWordFromLe(&pFrame->m_Data.m_Preq.m_le_wSize) + 24)
> FrameInfo.m_uiFrameSize)
{ // format error
tEplErrorHandlerkEvent DllEvent;
DllEvent.m_ulDllErrorEvents = EPL_DLL_ERR_INVALID_FORMAT;
DllEvent.m_uiNodeId = AmiGetByteFromLe(&pFrame->m_le_bSrcNodeId);
DllEvent.m_NmtState = NmtState;
Event.m_EventSink = kEplEventSinkErrk;
Event.m_EventType = kEplEventTypeDllError;
Event.m_NetTime = FrameInfo.m_NetTime;
Event.m_uiSize = sizeof (DllEvent);
Event.m_pArg = &DllEvent;
Ret = EplEventkPost(&Event);
break;
}
// forward PReq frame as RPDO to PDO module
Ret = EplPdokCbPdoReceived(&FrameInfo);
}
#if (EPL_DLL_PRES_READY_AFTER_SOC != FALSE)
if (pTxBuffer->m_pbBuffer != NULL)
{ // PRes does exist
// inform PDO module about PRes after PReq
FrameInfo.m_pFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
FrameInfo.m_uiFrameSize = pTxBuffer->m_uiMaxBufferLen;
Ret = EplPdokCbPdoTransmitted(&FrameInfo);
}
#endif
#endif
#if EDRV_EARLY_RX_INT == FALSE
// $$$ inform emergency protocol handling (error signaling module) about flags
}
#endif
// reset cycle counter
EplDllkInstance_g.m_uiCycleCount = 0;
break;
}
case kEplMsgTypePres:
{
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
tEplDllkNodeInfo* pIntNodeInfo;
tEplHeartbeatEvent HeartbeatEvent;
#endif
// PRes frame
NmtEvent = kEplNmtEventDllCePres;
uiNodeId = AmiGetByteFromLe(&pFrame->m_le_bSrcNodeId);
if ((NmtState >= kEplNmtCsPreOperational2)
&& (NmtState <= kEplNmtCsOperational))
{ // process PRes frames only in PreOp2, ReadyToOp and Op of CN
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
pIntNodeInfo = EplDllkGetNodeInfo(uiNodeId);
if (pIntNodeInfo == NULL)
{ // no node info structure available
Ret = kEplDllNoNodeInfo;
goto Exit;
}
}
else if (EplDllkInstance_g.m_DllState == kEplDllMsWaitPres)
{ // or process PRes frames in MsWaitPres
pIntNodeInfo = EplDllkInstance_g.m_pCurNodeInfo;
if ((pIntNodeInfo == NULL) || (pIntNodeInfo->m_uiNodeId != uiNodeId))
{ // ignore PRes, because it is from wrong CN
// $$$ maybe post event to NmtMn module
goto Exit;
}
// forward Flag2 to asynchronous scheduler
bFlag1 = AmiGetByteFromLe(&pFrame->m_Data.m_Asnd.m_Payload.m_StatusResponse.m_le_bFlag2);
Ret = EplDllkCalAsyncSetPendingRequests(uiNodeId,
((tEplDllAsyncReqPriority) ((bFlag1 & EPL_FRAME_FLAG2_PR) >> EPL_FRAME_FLAG2_PR_SHIFT)),
(bFlag1 & EPL_FRAME_FLAG2_RS));
#endif
}
else
{ // ignore PRes, because it was received in wrong NMT state
// but execute EplDllkChangeState() and post event to NMT module
break;
}
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
{ // check NMT state of CN
HeartbeatEvent.m_wErrorCode = EPL_E_NO_ERROR;
HeartbeatEvent.m_NmtState =
(tEplNmtState) (AmiGetByteFromLe(&pFrame->m_Data.m_Pres.m_le_bNmtStatus) | EPL_NMT_TYPE_CS);
if (pIntNodeInfo->m_NmtState != HeartbeatEvent.m_NmtState)
{ // NMT state of CN has changed -> post event to NmtMnu module
if (pIntNodeInfo->m_fSoftDelete == FALSE)
{ // normal isochronous CN
HeartbeatEvent.m_uiNodeId = uiNodeId;
Event.m_EventSink = kEplEventSinkNmtMnu;
Event.m_EventType = kEplEventTypeHeartbeat;
Event.m_uiSize = sizeof (HeartbeatEvent);
Event.m_pArg = &HeartbeatEvent;
}
else
{ // CN shall be deleted softly
Event.m_EventSink = kEplEventSinkDllkCal;
Event.m_EventType = kEplEventTypeDllkSoftDelNode;
Event.m_uiSize = sizeof (unsigned int);
Event.m_pArg = &pIntNodeInfo->m_uiNodeId;
}
Event.m_NetTime = FrameInfo.m_NetTime;
Ret = EplEventkPost(&Event);
// save current NMT state of CN in internal node structure
pIntNodeInfo->m_NmtState = HeartbeatEvent.m_NmtState;
}
}
#endif
// inform PDO module
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
if ((NmtState != kEplNmtCsPreOperational2)
&& (NmtState != kEplNmtMsPreOperational2))
{ // inform PDO module only in ReadyToOp and Op
// compare real frame size and PDO size?
if (((unsigned int) (AmiGetWordFromLe(&pFrame->m_Data.m_Pres.m_le_wSize) + 24)
> FrameInfo.m_uiFrameSize)
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
|| (AmiGetWordFromLe(&pFrame->m_Data.m_Pres.m_le_wSize) > pIntNodeInfo->m_wPresPayloadLimit)
#endif
)
{ // format error
tEplErrorHandlerkEvent DllEvent;
DllEvent.m_ulDllErrorEvents = EPL_DLL_ERR_INVALID_FORMAT;
DllEvent.m_uiNodeId = uiNodeId;
DllEvent.m_NmtState = NmtState;
Event.m_EventSink = kEplEventSinkErrk;
Event.m_EventType = kEplEventTypeDllError;
Event.m_NetTime = FrameInfo.m_NetTime;
Event.m_uiSize = sizeof (DllEvent);
Event.m_pArg = &DllEvent;
Ret = EplEventkPost(&Event);
break;
}
if ((NmtState != kEplNmtCsOperational)
&& (NmtState != kEplNmtMsOperational))
{
// reset RD flag and all other flags, but that does not matter, because they were processed above
AmiSetByteToLe(&pFrame->m_Data.m_Pres.m_le_bFlag1, 0);
}
Ret = EplPdokCbPdoReceived(&FrameInfo);
}
#endif
break;
}
case kEplMsgTypeSoc:
{
// SoC frame
NmtEvent = kEplNmtEventDllCeSoc;
if (NmtState >= kEplNmtMsNotActive)
{ // MN is active -> wrong msg type
break;
}
#if EPL_DLL_PRES_READY_AFTER_SOC != FALSE
// post PRes to transmit FIFO of the ethernet controller, but don't start
// transmission over bus
pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_PRES];
// Does PRes exist?
if (pTxBuffer->m_pbBuffer != NULL)
{ // PRes does exist
pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
// update frame (NMT state, RD, RS, PR, MS, EN flags)
if (NmtState < kEplNmtCsPreOperational2)
{ // NMT state is not PreOp2, ReadyToOp or Op
// fake NMT state PreOp2, because PRes will be sent only in PreOp2 or greater
NmtState = kEplNmtCsPreOperational2;
}
AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bNmtStatus, (BYTE) NmtState);
AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bFlag2, EplDllkInstance_g.m_bFlag2);
if (NmtState != kEplNmtCsOperational)
{ // mark PDO as invalid in NMT state Op
// $$$ reset only RD flag; set other flags appropriately
AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bFlag1, 0);
}
// $$$ make function that updates Pres, StatusRes
// mark PRes frame as ready for transmission
Ret = EdrvTxMsgReady(pTxBuffer);
}
#endif
if (NmtState >= kEplNmtCsPreOperational2)
{ // SoC frames only in PreOp2, ReadyToOp and Op
// trigger synchronous task
Event.m_EventSink = kEplEventSinkSync;
Event.m_EventType = kEplEventTypeSync;
Event.m_uiSize = 0;
Ret = EplEventkPost(&Event);
// update cycle counter
if (EplDllkInstance_g.m_DllConfigParam.m_uiMultiplCycleCnt > 0)
{ // multiplexed cycle active
EplDllkInstance_g.m_uiCycleCount = (EplDllkInstance_g.m_uiCycleCount + 1) % EplDllkInstance_g.m_DllConfigParam.m_uiMultiplCycleCnt;
}
}
// reprogram timer
#if EPL_TIMER_USE_HIGHRES != FALSE
if (EplDllkInstance_g.m_ullFrameTimeout != 0)
{
Ret = EplTimerHighReskModifyTimerNs(&EplDllkInstance_g.m_TimerHdlCycle, EplDllkInstance_g.m_ullFrameTimeout, EplDllkCbCnTimer, 0L, FALSE);
}
#endif
break;
}
case kEplMsgTypeSoa:
{
// SoA frame
NmtEvent = kEplNmtEventDllCeSoa;
if (NmtState >= kEplNmtMsNotActive)
{ // MN is active -> wrong msg type
break;
}
pTxFrame = NULL;
if ((NmtState & EPL_NMT_SUPERSTATE_MASK) != EPL_NMT_CS_EPLMODE)
{ // do not respond, if NMT state is < PreOp1 (i.e. not EPL_MODE)
break;
}
// check TargetNodeId
uiNodeId = AmiGetByteFromLe(&pFrame->m_Data.m_Soa.m_le_bReqServiceTarget);
if (uiNodeId == EplDllkInstance_g.m_DllConfigParam.m_uiNodeId)
{ // local node is the target of the current request
// check ServiceId
ReqServiceId = (tEplDllReqServiceId) AmiGetByteFromLe(&pFrame->m_Data.m_Soa.m_le_bReqServiceId);
if (ReqServiceId == kEplDllReqServiceStatus)
{ // StatusRequest
if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_STATUSRES].m_pbBuffer != NULL)
{ // StatusRes does exist
pTxFrame = (tEplFrame *) EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_STATUSRES].m_pbBuffer;
// update StatusRes frame (NMT state, EN, EC, RS, PR flags)
AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_StatusResponse.m_le_bNmtStatus, (BYTE) NmtState);
AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_StatusResponse.m_le_bFlag1, EplDllkInstance_g.m_bFlag1);
AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_StatusResponse.m_le_bFlag2, EplDllkInstance_g.m_bFlag2);
// send StatusRes
Ret = EdrvSendTxMsg(&EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_STATUSRES]);
if (Ret != kEplSuccessful)
{
goto Exit;
}
TGT_DBG_SIGNAL_TRACE_POINT(8);
// update error signaling
bFlag1 = AmiGetByteFromLe(&pFrame->m_Data.m_Soa.m_le_bFlag1);
if (((bFlag1 ^ EplDllkInstance_g.m_bMnFlag1) & EPL_FRAME_FLAG1_ER) != 0)
{ // exception reset flag was changed by MN
// assume same state for EC in next cycle (clear all other bits)
if ((bFlag1 & EPL_FRAME_FLAG1_ER) != 0)
{
// set EC and reset rest
EplDllkInstance_g.m_bFlag1 = EPL_FRAME_FLAG1_EC;
}
else
{
// reset complete flag 1 (including EC and EN)
EplDllkInstance_g.m_bFlag1 = 0;
}
}
// save flag 1 from MN for Status request response cycle
EplDllkInstance_g.m_bMnFlag1 = bFlag1;
}
}
else if (ReqServiceId == kEplDllReqServiceIdent)
{ // IdentRequest
if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_IDENTRES].m_pbBuffer != NULL)
{ // IdentRes does exist
pTxFrame = (tEplFrame *) EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_IDENTRES].m_pbBuffer;
// update IdentRes frame (NMT state, RS, PR flags)
AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_bNmtStatus, (BYTE) NmtState);
AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_bFlag2, EplDllkInstance_g.m_bFlag2);
// send IdentRes
Ret = EdrvSendTxMsg(&EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_IDENTRES]);
if (Ret != kEplSuccessful)
{
goto Exit;
}
TGT_DBG_SIGNAL_TRACE_POINT(7);
}
}
else if (ReqServiceId == kEplDllReqServiceNmtRequest)
{ // NmtRequest
if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_pbBuffer != NULL)
{ // NmtRequest does exist
// check if frame is not empty and not being filled
if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen > EPL_DLLK_BUFLEN_FILLING)
{
/*if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen < EPL_DLLK_BUFLEN_MIN)
{ // pad frame
EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen = EPL_DLLK_BUFLEN_MIN;
}*/
// memorize transmission
pTxFrame = (tEplFrame*)1;
// send NmtRequest
Ret = EdrvSendTxMsg(&EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ]);
if (Ret != kEplSuccessful)
{
goto Exit;
}
}
}
}
else if (ReqServiceId == kEplDllReqServiceUnspecified)
{ // unspecified invite
if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NONEPL].m_pbBuffer != NULL)
{ // non-EPL frame does exist
// check if frame is not empty and not being filled
if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NONEPL].m_uiTxMsgLen > EPL_DLLK_BUFLEN_FILLING)
{
/*if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen < EPL_DLLK_BUFLEN_MIN)
{ // pad frame
EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen = EPL_DLLK_BUFLEN_MIN;
}*/
// memorize transmission
pTxFrame = (tEplFrame*)1;
// send non-EPL frame
Ret = EdrvSendTxMsg(&EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NONEPL]);
if (Ret != kEplSuccessful)
{
goto Exit;
}
}
}
}
else if (ReqServiceId == kEplDllReqServiceNo)
{ // no async service requested -> do nothing
}
}
#if EPL_DLL_PRES_READY_AFTER_SOA != FALSE
if (pTxFrame == NULL)
{ // signal process function readiness of PRes frame
Event.m_EventSink = kEplEventSinkDllk;
Event.m_EventType = kEplEventTypeDllkPresReady;
Event.m_uiSize = 0;
Event.m_pArg = NULL;
Ret = EplEventkPost(&Event);
}
#endif
// inform PDO module
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0)
// Ret = EplPdokCbSoa(&FrameInfo);
#endif
// $$$ put SrcNodeId, NMT state and NetTime as HeartbeatEvent into eventqueue
// $$$ inform emergency protocol handling about flags
break;
}
case kEplMsgTypeAsnd:
{
// ASnd frame
NmtEvent = kEplNmtEventDllCeAsnd;
// ASnd service registered?
uiAsndServiceId = (unsigned int) AmiGetByteFromLe(&pFrame->m_Data.m_Asnd.m_le_bServiceId);
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
if ((EplDllkInstance_g.m_DllState >= kEplDllMsNonCyclic)
&& ((((tEplDllAsndServiceId) uiAsndServiceId) == kEplDllAsndStatusResponse)
|| (((tEplDllAsndServiceId) uiAsndServiceId) == kEplDllAsndIdentResponse)))
{ // StatusRes or IdentRes received
uiNodeId = AmiGetByteFromLe(&pFrame->m_le_bSrcNodeId);
if ((EplDllkInstance_g.m_LastReqServiceId == ((tEplDllReqServiceId) uiAsndServiceId))
&& (uiNodeId == EplDllkInstance_g.m_uiLastTargetNodeId))
{ // mark request as responded
EplDllkInstance_g.m_LastReqServiceId = kEplDllReqServiceNo;
}
if (((tEplDllAsndServiceId) uiAsndServiceId) == kEplDllAsndIdentResponse)
{ // memorize MAC address of CN for PReq
tEplDllkNodeInfo* pIntNodeInfo;
pIntNodeInfo = EplDllkGetNodeInfo(uiNodeId);
if (pIntNodeInfo == NULL)
{ // no node info structure available
Ret = kEplDllNoNodeInfo;
}
else
{
EPL_MEMCPY(pIntNodeInfo->m_be_abMacAddr, pFrame->m_be_abSrcMac, 6);
}
}
// forward Flag2 to asynchronous scheduler
bFlag1 = AmiGetByteFromLe(&pFrame->m_Data.m_Asnd.m_Payload.m_StatusResponse.m_le_bFlag2);
Ret = EplDllkCalAsyncSetPendingRequests(uiNodeId,
((tEplDllAsyncReqPriority) ((bFlag1 & EPL_FRAME_FLAG2_PR) >> EPL_FRAME_FLAG2_PR_SHIFT)),
(bFlag1 & EPL_FRAME_FLAG2_RS));
}
#endif
if (uiAsndServiceId < EPL_DLL_MAX_ASND_SERVICE_ID)
{ // ASnd service ID is valid
if (EplDllkInstance_g.m_aAsndFilter[uiAsndServiceId] == kEplDllAsndFilterAny)
{ // ASnd service ID is registered
// forward frame via async receive FIFO to userspace
Ret = EplDllkCalAsyncFrameReceived(&FrameInfo);
}
else if (EplDllkInstance_g.m_aAsndFilter[uiAsndServiceId] == kEplDllAsndFilterLocal)
{ // ASnd service ID is registered, but only local node ID or broadcasts
// shall be forwarded
uiNodeId = AmiGetByteFromLe(&pFrame->m_le_bDstNodeId);
if ((uiNodeId == EplDllkInstance_g.m_DllConfigParam.m_uiNodeId)
|| (uiNodeId == EPL_C_ADR_BROADCAST))
{ // ASnd frame is intended for us
// forward frame via async receive FIFO to userspace
Ret = EplDllkCalAsyncFrameReceived(&FrameInfo);
}
}
}
break;
}
default:
{
break;
}
}
if (NmtEvent != kEplNmtEventNoEvent)
{ // event for DLL and NMT state machine generated
Ret = EplDllkChangeState(NmtEvent, NmtState);
if (Ret != kEplSuccessful)
{
goto Exit;
}
if ((NmtEvent != kEplNmtEventDllCeAsnd)
&& ((NmtState <= kEplNmtCsPreOperational1) || (NmtEvent != kEplNmtEventDllCePres)))
{ // NMT state machine is not interested in ASnd frames and PRes frames when not CsNotActive or CsPreOp1
// inform NMT module
Event.m_EventSink = kEplEventSinkNmtk;
Event.m_EventType = kEplEventTypeNmtEvent;
Event.m_uiSize = sizeof (NmtEvent);
Event.m_pArg = &NmtEvent;
Ret = EplEventkPost(&Event);
}
}
Exit:
if (Ret != kEplSuccessful)
{
DWORD dwArg;
BENCHMARK_MOD_02_TOGGLE(9);
dwArg = EplDllkInstance_g.m_DllState | (NmtEvent << 8);
// Error event for API layer
Ret = EplEventkPostError(kEplEventSourceDllk,
Ret,
sizeof(dwArg),
&dwArg);
}
BENCHMARK_MOD_02_RESET(3);
return;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkCbFrameTransmitted()
//
// Description: called from EdrvInterruptHandler().
// It signals
//
// Parameters: pRxBuffer_p = receive buffer structure
//
// Returns: (none)
//
//
// State:
//
//---------------------------------------------------------------------------
static void EplDllkCbFrameTransmitted(tEdrvTxBuffer * pTxBuffer_p)
{
tEplKernel Ret = kEplSuccessful;
tEplEvent Event;
tEplDllAsyncReqPriority Priority;
tEplNmtState NmtState;
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0) \
&& (EPL_DLL_PRES_READY_AFTER_SOC == FALSE)
tEplFrameInfo FrameInfo;
#endif
NmtState = EplNmtkGetNmtState();
if (NmtState <= kEplNmtGsResetConfiguration)
{
goto Exit;
}
if ((pTxBuffer_p - EplDllkInstance_g.m_pTxBuffer) == EPL_DLLK_TXFRAME_NMTREQ)
{ // frame from NMT request FIFO sent
// mark Tx-buffer as empty
pTxBuffer_p->m_uiTxMsgLen = EPL_DLLK_BUFLEN_EMPTY;
// post event to DLL
Priority = kEplDllAsyncReqPrioNmt;
Event.m_EventSink = kEplEventSinkDllk;
Event.m_EventType = kEplEventTypeDllkFillTx;
EPL_MEMSET(&Event.m_NetTime, 0x00, sizeof(Event.m_NetTime));
Event.m_pArg = &Priority;
Event.m_uiSize = sizeof(Priority);
Ret = EplEventkPost(&Event);
}
else if ((pTxBuffer_p - EplDllkInstance_g.m_pTxBuffer) == EPL_DLLK_TXFRAME_NONEPL)
{ // frame from generic priority FIFO sent
// mark Tx-buffer as empty
pTxBuffer_p->m_uiTxMsgLen = EPL_DLLK_BUFLEN_EMPTY;
// post event to DLL
Priority = kEplDllAsyncReqPrioGeneric;
Event.m_EventSink = kEplEventSinkDllk;
Event.m_EventType = kEplEventTypeDllkFillTx;
EPL_MEMSET(&Event.m_NetTime, 0x00, sizeof(Event.m_NetTime));
Event.m_pArg = &Priority;
Event.m_uiSize = sizeof(Priority);
Ret = EplEventkPost(&Event);
}
#if ((((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0) \
&& (EPL_DLL_PRES_READY_AFTER_SOC == FALSE)) \
|| (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
else if ((pTxBuffer_p->m_EplMsgType == kEplMsgTypePreq)
|| (pTxBuffer_p->m_EplMsgType == kEplMsgTypePres))
{ // PRes resp. PReq frame sent
#if ((((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0) \
&& (EPL_DLL_PRES_READY_AFTER_SOC == FALSE))
{
// inform PDO module
FrameInfo.m_pFrame = (tEplFrame *) pTxBuffer_p->m_pbBuffer;
FrameInfo.m_uiFrameSize = pTxBuffer_p->m_uiMaxBufferLen;
Ret = EplPdokCbPdoTransmitted(&FrameInfo);
}
#endif
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
{
// if own Pres on MN, trigger SoA
if ((NmtState >= kEplNmtMsPreOperational2)
&& (pTxBuffer_p == &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_PRES]))
{
Ret = EplDllkChangeState(kEplNmtEventDllMeSoaTrig, NmtState);
}
}
#endif
#if EPL_DLL_PRES_READY_AFTER_SOA != FALSE
goto Exit;
#endif
}
#endif
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
else if (pTxBuffer_p->m_EplMsgType == kEplMsgTypeSoa)
{ // SoA frame sent
tEplNmtEvent NmtEvent = kEplNmtEventDllMeSoaSent;
// check if we are invited
if (EplDllkInstance_g.m_uiLastTargetNodeId == EplDllkInstance_g.m_DllConfigParam.m_uiNodeId)
{
tEplFrame *pTxFrame;
if (EplDllkInstance_g.m_LastReqServiceId == kEplDllReqServiceStatus)
{ // StatusRequest
if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_STATUSRES].m_pbBuffer != NULL)
{ // StatusRes does exist
pTxFrame = (tEplFrame *) EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_STATUSRES].m_pbBuffer;
// update StatusRes frame (NMT state, EN, EC, RS, PR flags)
AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_StatusResponse.m_le_bNmtStatus, (BYTE) NmtState);
AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_StatusResponse.m_le_bFlag1, EplDllkInstance_g.m_bFlag1);
AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_StatusResponse.m_le_bFlag2, EplDllkInstance_g.m_bFlag2);
// send StatusRes
Ret = EdrvSendTxMsg(&EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_STATUSRES]);
if (Ret != kEplSuccessful)
{
goto Exit;
}
TGT_DBG_SIGNAL_TRACE_POINT(8);
}
}
else if (EplDllkInstance_g.m_LastReqServiceId == kEplDllReqServiceIdent)
{ // IdentRequest
if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_IDENTRES].m_pbBuffer != NULL)
{ // IdentRes does exist
pTxFrame = (tEplFrame *) EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_IDENTRES].m_pbBuffer;
// update IdentRes frame (NMT state, RS, PR flags)
AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_bNmtStatus, (BYTE) NmtState);
AmiSetByteToLe(&pTxFrame->m_Data.m_Asnd.m_Payload.m_IdentResponse.m_le_bFlag2, EplDllkInstance_g.m_bFlag2);
// send IdentRes
Ret = EdrvSendTxMsg(&EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_IDENTRES]);
if (Ret != kEplSuccessful)
{
goto Exit;
}
TGT_DBG_SIGNAL_TRACE_POINT(7);
}
}
else if (EplDllkInstance_g.m_LastReqServiceId == kEplDllReqServiceNmtRequest)
{ // NmtRequest
if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_pbBuffer != NULL)
{ // NmtRequest does exist
// check if frame is not empty and not being filled
if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen > EPL_DLLK_BUFLEN_FILLING)
{
// check if this frame is a NMT command,
// then forward this frame back to NmtMnu module,
// because it needs the time, when this frame is
// actually sent, to start the timer for monitoring
// the NMT state change.
pTxFrame = (tEplFrame *) EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_pbBuffer;
if ((AmiGetByteFromLe(&pTxFrame->m_le_bMessageType)
== (BYTE) kEplMsgTypeAsnd)
&& (AmiGetByteFromLe(&pTxFrame->m_Data.m_Asnd.m_le_bServiceId)
== (BYTE) kEplDllAsndNmtCommand))
{ // post event directly to NmtMnu module
Event.m_EventSink = kEplEventSinkNmtMnu;
Event.m_EventType = kEplEventTypeNmtMnuNmtCmdSent;
Event.m_uiSize = EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ].m_uiTxMsgLen;
Event.m_pArg = pTxFrame;
Ret = EplEventkPost(&Event);
}
// send NmtRequest
Ret = EdrvSendTxMsg(&EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NMTREQ]);
if (Ret != kEplSuccessful)
{
goto Exit;
}
}
}
}
else if (EplDllkInstance_g.m_LastReqServiceId == kEplDllReqServiceUnspecified)
{ // unspecified invite
if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NONEPL].m_pbBuffer != NULL)
{ // non-EPL frame does exist
// check if frame is not empty and not being filled
if (EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NONEPL].m_uiTxMsgLen > EPL_DLLK_BUFLEN_FILLING)
{
// send non-EPL frame
Ret = EdrvSendTxMsg(&EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_NONEPL]);
if (Ret != kEplSuccessful)
{
goto Exit;
}
}
}
}
// ASnd frame was sent, remove the request
EplDllkInstance_g.m_LastReqServiceId = kEplDllReqServiceNo;
}
// forward event to ErrorHandler and PDO module
Event.m_EventSink = kEplEventSinkNmtk;
Event.m_EventType = kEplEventTypeNmtEvent;
Event.m_uiSize = sizeof (NmtEvent);
Event.m_pArg = &NmtEvent;
Ret = EplEventkPost(&Event);
if (Ret != kEplSuccessful)
{
goto Exit;
}
}
#endif
#if EPL_DLL_PRES_READY_AFTER_SOA != FALSE
else
{ // d.k.: Why that else? on CN it is entered on IdentRes and StatusRes
goto Exit;
}
// signal process function readiness of PRes frame
Event.m_EventSink = kEplEventSinkDllk;
Event.m_EventType = kEplEventTypeDllkPresReady;
Event.m_uiSize = 0;
Event.m_pArg = NULL;
Ret = EplEventkPost(&Event);
#endif
Exit:
if (Ret != kEplSuccessful)
{
DWORD dwArg;
BENCHMARK_MOD_02_TOGGLE(9);
dwArg = EplDllkInstance_g.m_DllState | (pTxBuffer_p->m_EplMsgType << 16);
// Error event for API layer
Ret = EplEventkPostError(kEplEventSourceDllk,
Ret,
sizeof(dwArg),
&dwArg);
}
return;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkCheckFrame()
//
// Description: check frame and set missing information
//
// Parameters: pFrame_p = ethernet frame
// uiFrameSize_p = size of frame
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
static tEplKernel EplDllkCheckFrame(tEplFrame * pFrame_p, unsigned int uiFrameSize_p)
{
tEplMsgType MsgType;
WORD wEtherType;
// check frame
if (pFrame_p != NULL)
{
// check SrcMAC
if (AmiGetQword48FromBe(pFrame_p->m_be_abSrcMac) == 0)
{
// source MAC address
EPL_MEMCPY(&pFrame_p->m_be_abSrcMac[0], &EplDllkInstance_g.m_be_abSrcMac[0], 6);
}
// check ethertype
wEtherType = AmiGetWordFromBe(&pFrame_p->m_be_wEtherType);
if (wEtherType == 0)
{
// assume EPL frame
wEtherType = EPL_C_DLL_ETHERTYPE_EPL;
AmiSetWordToBe(&pFrame_p->m_be_wEtherType, wEtherType);
}
if (wEtherType == EPL_C_DLL_ETHERTYPE_EPL)
{
// source node ID
AmiSetByteToLe(&pFrame_p->m_le_bSrcNodeId, (BYTE) EplDllkInstance_g.m_DllConfigParam.m_uiNodeId);
// check message type
MsgType = AmiGetByteFromLe(&pFrame_p->m_le_bMessageType);
if (MsgType == 0)
{
MsgType = kEplMsgTypeAsnd;
AmiSetByteToLe(&pFrame_p->m_le_bMessageType, (BYTE) MsgType);
}
if (MsgType == kEplMsgTypeAsnd)
{
// destination MAC address
AmiSetQword48ToBe(&pFrame_p->m_be_abDstMac[0], EPL_C_DLL_MULTICAST_ASND);
}
}
}
return kEplSuccessful;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkCbCnTimer()
//
// Description: called by timer module. It monitors the EPL cycle when it is a CN.
//
// Parameters: pEventArg_p = timer event argument
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
#if EPL_TIMER_USE_HIGHRES != FALSE
static tEplKernel PUBLIC EplDllkCbCnTimer(tEplTimerEventArg* pEventArg_p)
{
tEplKernel Ret = kEplSuccessful;
tEplNmtState NmtState;
#if EPL_TIMER_USE_HIGHRES != FALSE
if (pEventArg_p->m_TimerHdl != EplDllkInstance_g.m_TimerHdlCycle)
{ // zombie callback
// just exit
goto Exit;
}
#endif
NmtState = EplNmtkGetNmtState();
if (NmtState <= kEplNmtGsResetConfiguration)
{
goto Exit;
}
Ret = EplDllkChangeState(kEplNmtEventDllCeFrameTimeout, NmtState);
if (Ret != kEplSuccessful)
{
goto Exit;
}
// 2008/10/15 d.k. reprogramming of timer not necessary,
// because it will be programmed, when SoC is received.
/*
// reprogram timer
#if EPL_TIMER_USE_HIGHRES != FALSE
if ((NmtState > kEplNmtCsPreOperational1)
&& (EplDllkInstance_g.m_ullFrameTimeout != 0))
{
Ret = EplTimerHighReskModifyTimerNs(&EplDllkInstance_g.m_TimerHdlCycle, EplDllkInstance_g.m_ullFrameTimeout, EplDllkCbCnTimer, 0L, FALSE);
}
#endif
*/
Exit:
if (Ret != kEplSuccessful)
{
DWORD dwArg;
BENCHMARK_MOD_02_TOGGLE(9);
dwArg = EplDllkInstance_g.m_DllState | (kEplNmtEventDllCeFrameTimeout << 8);
// Error event for API layer
Ret = EplEventkPostError(kEplEventSourceDllk,
Ret,
sizeof(dwArg),
&dwArg);
}
return Ret;
}
#endif
#if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
//---------------------------------------------------------------------------
//
// Function: EplDllkCbMnTimerCycle()
//
// Description: called by timer module. It triggers the SoC when it is a MN.
//
// Parameters: pEventArg_p = timer event argument
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
static tEplKernel PUBLIC EplDllkCbMnTimerCycle(tEplTimerEventArg* pEventArg_p)
{
tEplKernel Ret = kEplSuccessful;
tEplNmtState NmtState;
#if EPL_TIMER_USE_HIGHRES != FALSE
if (pEventArg_p->m_TimerHdl != EplDllkInstance_g.m_TimerHdlCycle)
{ // zombie callback
// just exit
goto Exit;
}
#endif
NmtState = EplNmtkGetNmtState();
if (NmtState <= kEplNmtGsResetConfiguration)
{
goto Exit;
}
Ret = EplDllkChangeState(kEplNmtEventDllMeSocTrig, NmtState);
Exit:
if (Ret != kEplSuccessful)
{
DWORD dwArg;
BENCHMARK_MOD_02_TOGGLE(9);
dwArg = EplDllkInstance_g.m_DllState | (kEplNmtEventDllMeSocTrig << 8);
// Error event for API layer
Ret = EplEventkPostError(kEplEventSourceDllk,
Ret,
sizeof(dwArg),
&dwArg);
}
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkCbMnTimerResponse()
//
// Description: called by timer module. It monitors the PRes timeout.
//
// Parameters: pEventArg_p = timer event argument
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
static tEplKernel PUBLIC EplDllkCbMnTimerResponse(tEplTimerEventArg* pEventArg_p)
{
tEplKernel Ret = kEplSuccessful;
tEplNmtState NmtState;
#if EPL_TIMER_USE_HIGHRES != FALSE
if (pEventArg_p->m_TimerHdl != EplDllkInstance_g.m_TimerHdlResponse)
{ // zombie callback
// just exit
goto Exit;
}
#endif
NmtState = EplNmtkGetNmtState();
if (NmtState <= kEplNmtGsResetConfiguration)
{
goto Exit;
}
Ret = EplDllkChangeState(kEplNmtEventDllMePresTimeout, NmtState);
Exit:
if (Ret != kEplSuccessful)
{
DWORD dwArg;
BENCHMARK_MOD_02_TOGGLE(9);
dwArg = EplDllkInstance_g.m_DllState | (kEplNmtEventDllMePresTimeout << 8);
// Error event for API layer
Ret = EplEventkPostError(kEplEventSourceDllk,
Ret,
sizeof(dwArg),
&dwArg);
}
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkGetNodeInfo()
//
// Description: returns node info structure of the specified node.
//
// Parameters: uiNodeId_p = node ID
//
// Returns: tEplDllkNodeInfo* = pointer to internal node info structure
//
//
// State:
//
//---------------------------------------------------------------------------
static tEplDllkNodeInfo* EplDllkGetNodeInfo(unsigned int uiNodeId_p)
{
// $$$ d.k.: use hash algorithm to retrieve the appropriate node info structure
// if size of array is less than 254.
uiNodeId_p--; // node ID starts at 1 but array at 0
if (uiNodeId_p >= tabentries (EplDllkInstance_g.m_aNodeInfo))
{
return NULL;
}
else
{
return &EplDllkInstance_g.m_aNodeInfo[uiNodeId_p];
}
}
//---------------------------------------------------------------------------
//
// Function: EplDllkMnSendSoa()
//
// Description: it updates and transmits the SoA.
//
// Parameters: NmtState_p = current NMT state
// pDllStateProposed_p = proposed DLL state
// fEnableInvitation_p = enable invitation for asynchronous phase
// it will be disabled for EPL_C_DLL_PREOP1_START_CYCLES SoAs
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
static tEplKernel EplDllkMnSendSoa(tEplNmtState NmtState_p,
tEplDllState* pDllStateProposed_p,
BOOL fEnableInvitation_p)
{
tEplKernel Ret = kEplSuccessful;
tEdrvTxBuffer *pTxBuffer = NULL;
tEplFrame *pTxFrame;
tEplDllkNodeInfo* pNodeInfo;
*pDllStateProposed_p = kEplDllMsNonCyclic;
pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_SOA];
if (pTxBuffer->m_pbBuffer != NULL)
{ // SoA does exist
pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
if (fEnableInvitation_p != FALSE)
{ // fetch target of asynchronous phase
if (EplDllkInstance_g.m_bFlag2 == 0)
{ // own queues are empty
EplDllkInstance_g.m_LastReqServiceId = kEplDllReqServiceNo;
}
else if (((tEplDllAsyncReqPriority) (EplDllkInstance_g.m_bFlag2 >> EPL_FRAME_FLAG2_PR_SHIFT)) == kEplDllAsyncReqPrioNmt)
{ // frames in own NMT request queue available
EplDllkInstance_g.m_LastReqServiceId = kEplDllReqServiceNmtRequest;
}
else
{
EplDllkInstance_g.m_LastReqServiceId = kEplDllReqServiceUnspecified;
}
Ret = EplDllkCalAsyncGetSoaRequest(&EplDllkInstance_g.m_LastReqServiceId, &EplDllkInstance_g.m_uiLastTargetNodeId);
if (Ret != kEplSuccessful)
{
goto Exit;
}
if (EplDllkInstance_g.m_LastReqServiceId != kEplDllReqServiceNo)
{ // asynchronous phase will be assigned to one node
if (EplDllkInstance_g.m_uiLastTargetNodeId == EPL_C_ADR_INVALID)
{ // exchange invalid node ID with local node ID
EplDllkInstance_g.m_uiLastTargetNodeId = EplDllkInstance_g.m_DllConfigParam.m_uiNodeId;
// d.k. DLL state WaitAsndTrig is not helpful;
// so just step over to WaitSocTrig,
// because own ASnd is sent automatically in CbFrameTransmitted() after SoA.
//*pDllStateProposed_p = kEplDllMsWaitAsndTrig;
*pDllStateProposed_p = kEplDllMsWaitSocTrig;
}
else
{ // assignment to CN
*pDllStateProposed_p = kEplDllMsWaitAsnd;
}
pNodeInfo = EplDllkGetNodeInfo(EplDllkInstance_g.m_uiLastTargetNodeId);
if (pNodeInfo == NULL)
{ // no node info structure available
Ret = kEplDllNoNodeInfo;
goto Exit;
}
// update frame (EA, ER flags)
AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.m_le_bFlag1,
pNodeInfo->m_bSoaFlag1 & (EPL_FRAME_FLAG1_EA | EPL_FRAME_FLAG1_ER));
}
else
{ // no assignment of asynchronous phase
*pDllStateProposed_p = kEplDllMsWaitSocTrig;
EplDllkInstance_g.m_uiLastTargetNodeId = EPL_C_ADR_INVALID;
}
// update frame (target)
AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.m_le_bReqServiceId, (BYTE) EplDllkInstance_g.m_LastReqServiceId);
AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.m_le_bReqServiceTarget, (BYTE) EplDllkInstance_g.m_uiLastTargetNodeId);
}
else
{ // invite nobody
// update frame (target)
AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.m_le_bReqServiceId, (BYTE) 0);
AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.m_le_bReqServiceTarget, (BYTE) 0);
}
// update frame (NMT state)
AmiSetByteToLe(&pTxFrame->m_Data.m_Soa.m_le_bNmtStatus, (BYTE) NmtState_p);
// send SoA frame
Ret = EdrvSendTxMsg(pTxBuffer);
}
Exit:
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkMnSendSoc()
//
// Description: it updates and transmits the SoA.
//
// Parameters: (none)
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
static tEplKernel EplDllkMnSendSoc(void)
{
tEplKernel Ret = kEplSuccessful;
tEdrvTxBuffer* pTxBuffer = NULL;
tEplFrame* pTxFrame;
tEplEvent Event;
pTxBuffer = &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_SOC];
if (pTxBuffer->m_pbBuffer != NULL)
{ // SoC does exist
pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
// $$$ update NetTime
// send SoC frame
Ret = EdrvSendTxMsg(pTxBuffer);
if (Ret != kEplSuccessful)
{
goto Exit;
}
// trigger synchronous task
Event.m_EventSink = kEplEventSinkSync;
Event.m_EventType = kEplEventTypeSync;
Event.m_uiSize = 0;
Ret = EplEventkPost(&Event);
}
Exit:
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkMnSendPreq()
//
// Description: it updates and transmits the PReq for the next isochronous CN
// or own PRes if enabled.
//
// Parameters: NmtState_p = current NMT state
// pDllStateProposed_p = proposed DLL state
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
static tEplKernel EplDllkMnSendPreq(tEplNmtState NmtState_p,
tEplDllState* pDllStateProposed_p)
{
tEplKernel Ret = kEplSuccessful;
tEdrvTxBuffer *pTxBuffer = NULL;
tEplFrame *pTxFrame;
BYTE bFlag1 = 0;
if (EplDllkInstance_g.m_pCurNodeInfo == NULL)
{ // start with first isochronous CN
EplDllkInstance_g.m_pCurNodeInfo = EplDllkInstance_g.m_pFirstNodeInfo;
}
else
{ // iterate to next isochronous CN
EplDllkInstance_g.m_pCurNodeInfo = EplDllkInstance_g.m_pCurNodeInfo->m_pNextNodeInfo;
}
if (EplDllkInstance_g.m_pCurNodeInfo == NULL)
{ // last isochronous CN reached
Ret = EplDllkMnSendSoa(NmtState_p, pDllStateProposed_p, TRUE);
goto Exit;
}
else
{
pTxBuffer = EplDllkInstance_g.m_pCurNodeInfo->m_pPreqTxBuffer;
bFlag1 = EplDllkInstance_g.m_pCurNodeInfo->m_bSoaFlag1 & EPL_FRAME_FLAG1_EA;
*pDllStateProposed_p = kEplDllMsWaitPres;
// start PRes Timer
// $$$ d.k.: maybe move this call to CbFrameTransmitted(), because the time should run from there
#if EPL_TIMER_USE_HIGHRES != FALSE
Ret = EplTimerHighReskModifyTimerNs(&EplDllkInstance_g.m_TimerHdlResponse,
EplDllkInstance_g.m_pCurNodeInfo->m_dwPresTimeout,
EplDllkCbMnTimerResponse,
0L,
FALSE);
#endif
}
if (pTxBuffer == NULL)
{ // PReq does not exist
Ret = kEplDllTxBufNotReady;
goto Exit;
}
pTxFrame = (tEplFrame *) pTxBuffer->m_pbBuffer;
if (pTxFrame != NULL)
{ // PReq does exist
if (NmtState_p == kEplNmtMsOperational)
{ // leave RD flag untouched
bFlag1 |= AmiGetByteFromLe(&pTxFrame->m_Data.m_Preq.m_le_bFlag1) & EPL_FRAME_FLAG1_RD;
}
if (pTxBuffer == &EplDllkInstance_g.m_pTxBuffer[EPL_DLLK_TXFRAME_PRES])
{ // PRes of MN will be sent
// update NMT state
AmiSetByteToLe(&pTxFrame->m_Data.m_Pres.m_le_bNmtStatus, (BYTE) NmtState_p);
*pDllStateProposed_p = kEplDllMsWaitSoaTrig;
}
// $$$ d.k. set EPL_FRAME_FLAG1_MS if necessary
// update frame (Flag1)
AmiSetByteToLe(&pTxFrame->m_Data.m_Preq.m_le_bFlag1, bFlag1);
// calculate frame size from payload size
pTxBuffer->m_uiTxMsgLen = AmiGetWordFromLe(&pTxFrame->m_Data.m_Preq.m_le_wSize) + 24;
// send PReq frame
Ret = EdrvSendTxMsg(pTxBuffer);
}
else
{
Ret = kEplDllTxFrameInvalid;
}
Exit:
return Ret;
}
//---------------------------------------------------------------------------
//
// Function: EplDllkAsyncFrameNotReceived()
//
// Description: passes empty ASnd frame to receive FIFO.
// It will be called only for frames with registered AsndServiceIds
// (only kEplDllAsndFilterAny).
//
// Parameters: none
//
// Returns: tEplKernel = error code
//
//
// State:
//
//---------------------------------------------------------------------------
static tEplKernel EplDllkAsyncFrameNotReceived(tEplDllReqServiceId ReqServiceId_p, unsigned int uiNodeId_p)
{
tEplKernel Ret = kEplSuccessful;
BYTE abBuffer[18];
tEplFrame* pFrame = (tEplFrame*) abBuffer;
tEplFrameInfo FrameInfo;
// check if previous SoA invitation was not answered
switch (ReqServiceId_p)
{
case kEplDllReqServiceIdent:
case kEplDllReqServiceStatus:
// ASnd service registered?
if (EplDllkInstance_g.m_aAsndFilter[ReqServiceId_p] == kEplDllAsndFilterAny)
{ // ASnd service ID is registered
AmiSetByteToLe(&pFrame->m_le_bSrcNodeId, (BYTE) uiNodeId_p);
// EPL MsgType ASnd
AmiSetByteToLe(&pFrame->m_le_bMessageType, (BYTE) kEplMsgTypeAsnd);
// ASnd Service ID
AmiSetByteToLe(&pFrame->m_Data.m_Asnd.m_le_bServiceId, (BYTE) ReqServiceId_p);
// create frame info structure
FrameInfo.m_pFrame = pFrame;
FrameInfo.m_uiFrameSize = 18; // empty non existing ASnd frame
// forward frame via async receive FIFO to userspace
Ret = EplDllkCalAsyncFrameReceived(&FrameInfo);
}
break;
default:
// no invitation issued or it was successfully answered or it is uninteresting
break;
}
return Ret;
}
#endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
#endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0)
// EOF